openstack
/
manila
Code Issues Proposed changes

Replace string driver modes with boolean value 

Due to unclear meanings of existing names for share drivers modes it was
decided to replace string driver modes with boolean value, since we have only
two possible values that will clearly say what it used for by name of opt.

This replacement includes following changes:
- String opt 'share_driver_mode' is replaced with
bool opt 'driver_handles_share_servers'. New bool opt does not have
default value and should be defined explicitly.
- Class ShareDriver (parent class for share drivers) now expects additional
argument 'driver_handles_share_servers' which is mandatory and should be
provided by child classes. Expected values are boolean or tuple/list/set of
booleans that says what modes are supported. Above new config opt will be
compared to these.
- Update interfaces 'setup_server' and 'teardown_server' of class ShareDriver.
These interfaces now consider driver modes and call new additional private
methods only when driver is enabled to mode with share servers handling.
These new private methods are '_setup_server' and '_teardown_server', they
should be redefined by child classes when share servers should be handled by
Manila.
- To get know current driver mode within child classes just call property
'driver_handles_share_servers'. It can not be changed by child classes and
returns value that is set by config opt with same name.
- Remove methods 'setup_server' and 'teardown_server' from all share drivers,
that do not support handling of share servers.
- Rename methods 'setup_server' and 'teardown_server' to appropriate
private methods for drivers that do support handling of share servers.
- Update unit tests related to all changed places.
- Make Devstack set new mandatory bool opt.

Implements bp rename-driver-modes

Change-Id: I33402959bc4bbc34cfd4d7308ad0a7bcff3669b5
This commit is contained in:
Valeriy Ponomaryov 2015-01-16 13:39:52 +02:00
parent 0faa3afdbb
commit b719d0ffa6
26 changed files with 308 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
contrib/devstack/lib/manila
View File

@ -142,6 +142,7 @@ function configure_default_backends {
iniset $MANILA_CONF $group_name service_image_name $MANILA_SERVICE_IMAGE_NAME
iniset $MANILA_CONF $group_name service_instance_user $MANILA_SERVICE_INSTANCE_USER
iniset $MANILA_CONF $group_name service_instance_password $MANILA_SERVICE_INSTANCE_PASSWORD
iniset $MANILA_CONF $group_name driver_handles_share_servers True
done
}

8
manila/common/constants.py
View File

@ -51,11 +51,3 @@ PING_PORTS = (
SERVICE_INSTANCE_SECGROUP_DATA = (
CIFS_PORTS + NFS_PORTS + SSH_PORTS + PING_PORTS)
SINGLE_SVM_MODE = 'single_svm'
MULTI_SVM_MODE = 'multi_svm'
VALID_SHARE_DRIVER_MODES = (
SINGLE_SVM_MODE,
MULTI_SVM_MODE,
)

189
manila/share/driver.py
View File

@ -1,4 +1,5 @@
# Copyright 2012 NetApp
# Copyright 2015 Mirantis inc.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
@ -20,9 +21,7 @@ Drivers for shares.
import time
from oslo.config import cfg
import six
from manila.common import constants
from manila import exception
from manila.i18n import _LE
from manila import network
@ -53,13 +52,15 @@ share_opts = [
"If not set, the share backend's config group will be used."
"If an option is not found within provided group, then"
"'DEFAULT' group will be used for search of option."),
cfg.StrOpt(
'share_driver_mode',
default=None,
help="One specific mode for driver to use. Available values: "
"%s. What modes are supported and can be used is "
"up to driver. If set None then default will be used." %
six.text_type(constants.VALID_SHARE_DRIVER_MODES)),
cfg.BoolOpt(
'driver_handles_share_servers',
help="There are two possible approaches for share drivers in Manila. "
"First is when share driver is able to handle share-servers and "
"second when not. Drivers can support either both or only one "
"of these approaches. So, set this opt to True if share driver "
"is able to handle share servers and it is desired mode else set "
"False. It is set to None by default to make this choice "
"intentional."),
]
ssh_opts = [
@ -153,17 +154,32 @@ class GaneshaMixin(object):
class ShareDriver(object):
"""Class defines interface of NAS driver."""
def __init__(self, *args, **kwargs):
def __init__(self, driver_handles_share_servers, *args, **kwargs):
"""Implements base functionality for share drivers.
:param driver_handles_share_servers: expected boolean value or
tuple/list/set of boolean values.
There are two possible approaches for share drivers in Manila.
First is when share driver is able to handle share-servers and
second when not.
Drivers can support either both or only one of these approaches.
So, it is allowed to be 'True' when share driver does support
handling of share servers and allowed to be 'False' when does
support usage of unhandled share-servers that are not tracked by
Manila.
Share drivers are allowed to work only in one of two possible
driver modes, that is why only one should be chosen.
"""
super(ShareDriver, self).__init__()
self.configuration = kwargs.get('configuration', None)
if self.configuration:
self.configuration.append_config_values(share_opts)
network_config_group = (self.configuration.network_config_group or
self.configuration.config_group)
self.mode = self.configuration.safe_get('share_driver_mode')
else:
network_config_group = None
self.mode = CONF.share_driver_mode
self._verify_share_server_handling(driver_handles_share_servers)
if hasattr(self, 'init_execute_mixin'):
# Instance with 'ExecuteMixin'
@ -173,55 +189,36 @@ class ShareDriver(object):
self.init_execute_mixin(*args, **kwargs) # pylint: disable=E1101
self.network_api = network.API(config_group_name=network_config_group)
def _validate_driver_mode(self, mode):
valid = constants.VALID_SHARE_DRIVER_MODES
if mode not in valid:
data = {'mode': mode, 'valid': valid}
msg = ("Provided unsupported driver mode '%(mode)s'. List of "
"valid driver modes is %(valid)s." % data)
LOG.error(msg)
raise exception.InvalidParameterValue(msg)
return mode
@property
def driver_handles_share_servers(self):
if self.configuration:
return self.configuration.safe_get('driver_handles_share_servers')
return CONF.driver_handles_share_servers
def get_driver_mode(self, supported_driver_modes):
"""Verify and return driver mode.
def _verify_share_server_handling(self, driver_handles_share_servers):
if not isinstance(self.driver_handles_share_servers, bool):
raise exception.ManilaException(
"Config opt 'driver_handles_share_servers' has improper "
"value - '%s'. Please define it as boolean." %
self.driver_handles_share_servers)
elif isinstance(driver_handles_share_servers, bool):
driver_handles_share_servers = [driver_handles_share_servers]
elif not isinstance(driver_handles_share_servers, (tuple, list, set)):
raise exception.ManilaException(
"Improper data provided for 'driver_handles_share_servers' - "
"%s" % driver_handles_share_servers)
Call this method within share driver to get value for 'mode' attr,
if any(not isinstance(v, bool) for v in driver_handles_share_servers):
raise exception.ManilaException(
"Provided wrong data: %s" % driver_handles_share_servers)
:param supported_driver_modes: text value or list/tuple of text values
with supported modes by share driver, see list of available values
in manila.common.constants.VALID_SHARE_DRIVER_MODES
:returns: text_type -- name of enabled driver mode.
:raises: exception.InvalidParameterValue
"""
msg = None
if isinstance(supported_driver_modes, six.string_types):
supported_driver_modes = [supported_driver_modes, ]
if not isinstance(supported_driver_modes, (tuple, list)):
msg = ("Provided param 'supported_driver_modes' has unexpected "
"type - '%s'." % type(supported_driver_modes))
elif not len(supported_driver_modes):
msg = "At least one mode should be supported by share driver."
elif self.mode:
if self.mode not in supported_driver_modes:
data = {'mode': self.mode, 'supported': supported_driver_modes}
msg = ("Unsupported driver mode '%(mode)s' is provided. "
"List of supported is %(supported)s." % data)
else:
return self._validate_driver_mode(self.mode)
elif len(supported_driver_modes) > 1:
msg = ("Driver mode was not specified explicitly and amount of "
"supported driver modes %s is bigger than one, please "
"specify it using config option 'share_driver_mode'." %
six.text_type(supported_driver_modes))
if msg:
LOG.error(msg)
raise exception.InvalidParameterValue(msg)
return self._validate_driver_mode(supported_driver_modes[0])
if (self.driver_handles_share_servers not in
driver_handles_share_servers):
raise exception.ManilaException(
"Driver does not support mode 'driver_handles_share_servers="
"%(actual)s'. It can be used only with value '%(allowed)s'." %
{'actual': self.driver_handles_share_servers,
'allowed': driver_handles_share_servers})
def create_share(self, context, share, share_server=None):
"""Is called to create share."""
@ -258,11 +255,9 @@ class ShareDriver(object):
def check_for_setup_error(self):
"""Check for setup error."""
pass
def do_setup(self, context):
"""Any initialization the share driver does while starting."""
pass
def get_share_stats(self, refresh=False):
"""Get share status.
@ -300,31 +295,61 @@ class ShareDriver(object):
if self.get_network_allocations_number():
self.network_api.deallocate_network(context, share_server_id)
def setup_server(self, network_info, metadata=None):
"""Set up and configures share server with given network parameters."""
pass
def setup_server(self, *args, **kwargs):
if self.driver_handles_share_servers:
return self._setup_server(*args, **kwargs)
else:
LOG.debug(
"Skipping step 'setup share server', because driver is "
"enabled with mode when Manila does not handle share servers.")
def teardown_server(self, server_details, security_services=None):
"""Teardown share server."""
pass
def _setup_server(self, network_info, metadata=None):
"""Sets up and configures share server with given network parameters.
def _update_share_stats(self):
"""Retrieve stats info from share group."""
Redefine it within share driver when it is going to handle share
servers.
"""
raise NotImplementedError()
def teardown_server(self, *args, **kwargs):
if self.driver_handles_share_servers:
return self._teardown_server(*args, **kwargs)
else:
LOG.debug(
"Skipping step 'teardown share server', because driver is "
"enabled with mode when Manila does not handle share servers.")
def _teardown_server(self, server_details, security_services=None):
"""Tears down share server.
Redefine it within share driver when it is going to handle share
servers.
"""
raise NotImplementedError()
def _update_share_stats(self, data=None):
"""Retrieve stats info from share group.
:param data: dict -- dict with key-value pairs to redefine common ones.
"""
LOG.debug("Updating share stats.")
backend_name = (self.configuration.safe_get('share_backend_name') or
CONF.share_backend_name)
LOG.debug("Updating share stats")
data = {}
backend_name = self.configuration.safe_get('share_backend_name')
# Note(zhiteng): These information are driver/backend specific,
# each driver may define these values in its own config options
# or fetch from driver specific configuration file.
data["share_backend_name"] = backend_name or 'Generic_NFS'
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'Open Source'
data["driver_version"] = '1.0'
data["storage_protocol"] = None
data['total_capacity_gb'] = 'infinite'
data['free_capacity_gb'] = 'infinite'
data['reserved_percentage'] = 0
data['QoS_support'] = False
self._stats = data
common = dict(
share_backend_name=backend_name or 'Generic_NFS',
driver_handles_share_servers=self.driver_handles_share_servers,
vendor_name='Open Source',
driver_version='1.0',
storage_protocol=None,
total_capacity_gb='infinite',
free_capacity_gb='infinite',
reserved_percentage=0,
QoS_support=False)
if isinstance(data, dict):
common.update(data)
self._stats = common

39
manila/share/drivers/emc/driver.py
View File

@ -63,15 +63,19 @@ CONF.register_opts(EMC_NAS_OPTS)
class EMCShareDriver(driver.ShareDriver):
"""EMC specific NAS driver. Allows for NFS and CIFS NAS storage usage."""
def __init__(self, *args, **kwargs):
super(EMCShareDriver, self).__init__(*args, **kwargs)
self.configuration = kwargs.get('configuration', None)
if self.configuration:
self.configuration.append_config_values(EMC_NAS_OPTS)
self.backend_name = self.configuration.safe_get(
'emc_share_backend')
else:
self.backend_name = CONF.emc_share_backend
self.backend_name = self.backend_name or 'EMC_NAS_Storage'
self.plugin_manager = manager.EMCPluginManager(
namespace='manila.share.drivers.emc.plugins')
self.plugin = None
self.plugin = self.plugin_manager.load_plugin(self.backend_name, LOG)
super(EMCShareDriver, self).__init__(
self.plugin.driver_handles_share_servers, *args, **kwargs)
def create_share(self, context, share, share_server=None):
"""Is called to create share."""
@ -122,42 +126,29 @@ class EMCShareDriver(driver.ShareDriver):
def do_setup(self, context):
"""Any initialization the share driver does while starting."""
backend_name = self.configuration.safe_get('emc_share_backend')
self.plugin = self.plugin_manager.load_plugin(backend_name, LOG)
self.mode = self.get_driver_mode(self.plugin.supported_driver_modes)
self.plugin.connect(self, context)
def _update_share_stats(self):
"""Retrieve stats info from share."""
LOG.debug("Updating share stats.")
data = {}
backend_name = self.configuration.safe_get(
'share_backend_name') or "EMC_NAS_Storage"
data["share_backend_name"] = backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'EMC'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS_CIFS'
data['total_capacity_gb'] = 'infinite'
data['free_capacity_gb'] = 'infinite'
data['reserved_percentage'] = 0
data['QoS_support'] = False
data = dict(
share_backend_name=backend_name,
vendor_name='EMC',
storage_protocol='NFS_CIFS')
self.plugin.update_share_stats(data)
self._stats = data
super(EMCShareDriver, self)._update_share_stats(data)
def get_network_allocations_number(self):
"""Returns number of network allocations for creating VIFs."""
return self.plugin.get_network_allocations_number(self)
def setup_server(self, network_info, metadata=None):
def _setup_server(self, network_info, metadata=None):
"""Set up and configures share server with given network parameters."""
return self.plugin.setup_server(self, network_info, metadata)
def teardown_server(self, server_details, security_services=None):
def _teardown_server(self, server_details, security_services=None):
"""Teardown share server."""
return self.plugin.teardown_server(self,
server_details,

5
manila/share/drivers/emc/plugins/base.py
View File

@ -25,8 +25,9 @@ class StorageConnection(object):
def __init__(self, logger):
self.logger = logger
# NOTE(vponomaryov): redefine 'supported_driver_modes' within plugin.
self.supported_driver_modes = None
# NOTE(vponomaryov): redefine 'driver_handles_share_servers' within
# plugin.
self.driver_handles_share_servers = None
@abc.abstractmethod
def create_share(self, emc_share_driver, context, share, share_server):

3
manila/share/drivers/emc/plugins/vnx/connection.py
View File

@ -17,7 +17,6 @@ from oslo.utils import excutils
from oslo.utils import units
import six
from manila.common import constants as const
from manila import db as manila_db
from manila import exception
from manila.i18n import _
@ -48,7 +47,7 @@ class VNXStorageConnection(driver.StorageConnection):
self._pool_name = None
self._pool = None
self._filesystems = {}
self.supported_driver_modes = const.MULTI_SVM_MODE
self.driver_handles_share_servers = True
def create_share(self, emc_share_driver, context, share,
share_server=None):

29
manila/share/drivers/generic.py
View File

@ -109,12 +109,11 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
def __init__(self, db, *args, **kwargs):
"""Do initialization."""
super(GenericShareDriver, self).__init__(*args, **kwargs)
super(GenericShareDriver, self).__init__(True, *args, **kwargs)
self.admin_context = context.get_admin_context()
self.db = db
self.configuration.append_config_values(share_opts)
self.configuration.append_config_values(service_instance.server_opts)
self.mode = self.get_driver_mode(const.MULTI_SVM_MODE)
self._helpers = {}
self.backend_name = self.configuration.safe_get(
'share_backend_name') or "Cinder_Volumes"
@ -450,23 +449,11 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
def _update_share_stats(self):
"""Retrieve stats info from share volume group."""
LOG.debug("Updating share stats")
data = {}
data["share_backend_name"] = self.backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'Open Source'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS_CIFS'
data['total_capacity_gb'] = 'infinite'
data['free_capacity_gb'] = 'infinite'
data['reserved_percentage'] = (self.configuration.
reserved_share_percentage)
data['QoS_support'] = False
self._stats = data
data = dict(
share_backend_name=self.backend_name,
storage_protocol='NFS_CIFS',
reserved_percentage=(self.configuration.reserved_share_percentage))
super(GenericShareDriver, self)._update_share_stats(data)
@ensure_server
def create_share_from_snapshot(self, context, share, snapshot,
@ -597,7 +584,7 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
# use service instance provided by Nova.
return 0
def setup_server(self, network_info, metadata=None):
def _setup_server(self, network_info, metadata=None):
msg = "Creating share server '%s'."
LOG.debug(msg % network_info['server_id'])
server = self.service_instance_manager.set_up_service_instance(
@ -610,7 +597,7 @@ class GenericShareDriver(driver.ExecuteMixin, driver.ShareDriver):
helper.init_helper(server)
return server
def teardown_server(self, server_details, security_services=None):
def _teardown_server(self, server_details, security_services=None):
instance_id = server_details.get("instance_id")
LOG.debug("Removing share infrastructure for service instance '%s'.",
instance_id)

39
manila/share/drivers/glusterfs.py
View File

@ -32,7 +32,6 @@ import xml.etree.cElementTree as etree
from oslo.config import cfg
import six
from manila.common import constants as const
from manila import exception
from manila.i18n import _
from manila.i18n import _LE
@ -93,14 +92,13 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
"""Execute commands relating to Shares."""
def __init__(self, db, *args, **kwargs):
super(GlusterfsShareDriver, self).__init__(*args, **kwargs)
super(GlusterfsShareDriver, self).__init__(False, *args, **kwargs)
self.db = db
self._helpers = None
self.gluster_address = None
self.configuration.append_config_values(GlusterfsManilaShare_opts)
self.backend_name = self.configuration.safe_get(
'share_backend_name') or 'GlusterFS'
self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
def do_setup(self, context):
"""Native mount the GlusterFS volume and tune it."""
@ -242,16 +240,6 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
local_vol_path)
return os.path.join(local_vol_path, share['name'])
def get_share_stats(self, refresh=False):
"""Get share stats.
If 'refresh' is True, run update the stats first.
"""
if refresh:
self._update_share_stats()
return self._stats
def _update_share_stats(self):
"""Retrieve stats info from the GlusterFS volume."""
@ -264,23 +252,14 @@ class GlusterfsShareDriver(driver.ExecuteMixin, driver.ShareDriver):
)
smpv = os.statvfs(self._get_mount_point_for_gluster_vol())
LOG.debug("Updating share stats")
data = {}
data["share_backend_name"] = self.backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'Red Hat'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS'
data['reserved_percentage'] = \
self.configuration.reserved_share_percentage
data['QoS_support'] = False
data['total_capacity_gb'] = (smpv.f_blocks * smpv.f_frsize) >> 30
data['free_capacity_gb'] = (smpv.f_bavail * smpv.f_frsize) >> 30
self._stats = data
data = dict(
storage_protocol='NFS',
vendor_name='Red Hat',
share_backend_name=self.backend_name,
reserved_percentage=self.configuration.reserved_share_percentage,
total_capacity_gb=(smpv.f_blocks * smpv.f_frsize) >> 30,
free_capacity_gb=(smpv.f_bavail * smpv.f_frsize) >> 30)
super(GlusterfsShareDriver, self)._update_share_stats(data)
def get_network_allocations_number(self):
return 0

37
manila/share/drivers/glusterfs_native.py
View File

@ -33,7 +33,6 @@ import tempfile
from oslo.config import cfg
import six
from manila.common import constants as const
from manila import exception
from manila.i18n import _
from manila.i18n import _LI
@ -76,7 +75,8 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
"""
def __init__(self, db, *args, **kwargs):
super(GlusterfsNativeShareDriver, self).__init__(*args, **kwargs)
super(GlusterfsNativeShareDriver, self).__init__(
False, *args, **kwargs)
self.db = db
self._helpers = None
self.gluster_unused_vols_dict = {}
@ -85,7 +85,6 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
glusterfs_native_manila_share_opts)
self.backend_name = self.configuration.safe_get(
'share_backend_name') or 'GlusterFS-Native'
self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
def do_setup(self, context):
"""Setup the GlusterFS volumes."""
@ -489,32 +488,15 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
# set dynamically.
self._restart_gluster_vol(gluster_addr)
def get_share_stats(self, refresh=False):
"""Get share stats.
If 'refresh' is True, update the stats first.
"""
if refresh:
self._update_share_stats()
return self._stats
def _update_share_stats(self):
"""Send stats info for the GlusterFS volume."""
LOG.debug("Updating share stats")
data = {}
data["share_backend_name"] = self.backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'Red Hat'
data["driver_version"] = '1.1'
data["storage_protocol"] = 'glusterfs'
data['reserved_percentage'] = (
self.configuration.reserved_share_percentage)
data['QoS_support'] = False
data = dict(
share_backend_name=self.backend_name,
vendor_name='Red Hat',
driver_version='1.1',
storage_protocol='glusterfs',
reserved_percentage=self.configuration.reserved_share_percentage)
# We don't use a service mount to get stats data.
# Instead we use glusterfs quota feature and use that to limit
@ -524,7 +506,8 @@ class GlusterfsNativeShareDriver(driver.ExecuteMixin, driver.ShareDriver):
# specific stats via the gluster cli.
data['total_capacity_gb'] = 'infinite'
data['free_capacity_gb'] = 'infinite'
self._stats = data
super(GlusterfsNativeShareDriver, self)._update_share_stats(data)
def ensure_share(self, context, share, share_server=None):
"""Invoked to ensure that share is exported."""

40
manila/share/drivers/huawei/huawei_nas.py
View File

@ -20,7 +20,6 @@ from oslo.config import cfg
from oslo.utils import excutils
from oslo.utils import units
from manila.common import constants as const
from manila import exception
from manila.i18n import _, _LI, _LW
from manila.openstack.common import log as logging
@ -51,14 +50,13 @@ class HuaweiNasDriver(driver.ShareDriver):
def __init__(self, *args, **kwargs):
"""Do initialization."""
LOG.debug("Enter into init function.")
super(HuaweiNasDriver, self).__init__(*args, **kwargs)
super(HuaweiNasDriver, self).__init__(False, *args, **kwargs)
self.configuration = kwargs.get('configuration', None)
if self.configuration:
self.configuration.append_config_values(huawei_opts)
self.helper = huawei_helper.RestHelper(self.configuration)
else:
raise exception.InvalidShare(_("Huawei configuration missing."))
self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
def check_for_setup_error(self):
"""Returns an error if prerequisites aren't met."""
@ -112,13 +110,6 @@ class HuaweiNasDriver(driver.ShareDriver):
return location
def get_share_stats(self, refresh=False):
"""Get a share stats."""
LOG.debug("Get a share stats.")
data = self._update_share_stats()
return data
def create_share_from_snapshot(self, context, share, snapshot,
share_server=None):
"""Is called to create share from snapshot."""
@ -195,28 +186,15 @@ class HuaweiNasDriver(driver.ShareDriver):
def _update_share_stats(self):
"""Retrieve status info from share group."""
capacity = self.helper._get_capacity()
# Note(zhiteng): These information are driver/backend specific,
# each driver may define these values in its own config options
# or fetch from driver specific configuration file.
data = {}
backend_name = self.configuration.safe_get('share_backend_name')
data["share_backend_name"] = backend_name or 'HUAWEI_NAS_Driver'
data["vendor_name"] = 'Huawei'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS_CIFS'
data['total_capacity_gb'] = capacity['total_capacity']
data['free_capacity_gb'] = capacity['free_capacity']
data['reserved_percentage'] = 0
data["share_driver_mode"] = self.mode
data['QoS_support'] = False
return data
capacity = self.helper._get_capacity()
data = dict(
share_backend_name=backend_name or 'HUAWEI_NAS_Driver',
vendor_name='Huawei',
storage_protocol='NFS_CIFS',
total_capacity_gb=capacity['total_capacity'],
free_capacity_gb=capacity['free_capacity'])
super(HuaweiNasDriver, self)._update_share_stats(data)
def _get_wait_interval(self):
"""Get wait interval from huawei conf file."""

23
manila/share/drivers/ibm/gpfs.py
View File

@ -43,7 +43,6 @@ from oslo.utils import units
from oslo_concurrency import processutils
import six
from manila.common import constants as const
from manila import exception
from manila.i18n import _, _LE, _LI
from manila.openstack.common import log as logging
@ -124,13 +123,12 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
def __init__(self, db, *args, **kwargs):
"""Do initialization."""
super(GPFSShareDriver, self).__init__(*args, **kwargs)
super(GPFSShareDriver, self).__init__(False, *args, **kwargs)
self.db = db
self._helpers = {}
self.configuration.append_config_values(gpfs_share_opts)
self.backend_name = self.configuration.safe_get(
'share_backend_name') or "IBM Storage System"
self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
self.sshpool = None
self.ssh_connections = {}
self._gpfs_execute = None
@ -499,18 +497,11 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
def _update_share_stats(self):
"""Retrieve stats info from share volume group."""
LOG.debug("Updating share stats")
data = {}
data["share_backend_name"] = self.backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'IBM'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS'
data['reserved_percentage'] = \
self.configuration.reserved_share_percentage
data['QoS_support'] = False
data = dict(
share_backend_name=self.backend_name,
vendor_name='IBM',
storage_protocol='NFS',
reserved_percentage=self.configuration.reserved_share_percentage)
free, capacity = self._get_available_capacity(
self.configuration.gpfs_mount_point_base)
@ -518,7 +509,7 @@ class GPFSShareDriver(driver.ExecuteMixin, driver.GaneshaMixin,
data['total_capacity_gb'] = math.ceil(capacity / units.Gi)
data['free_capacity_gb'] = math.ceil(free / units.Gi)
self._stats = data
super(GPFSShareDriver, self)._update_share_stats(data)
def _get_helper(self, share):
if share['share_proto'].startswith('NFS'):

31
manila/share/drivers/netapp/cluster_mode.py
View File

@ -28,7 +28,6 @@ from oslo.utils import excutils
from oslo.utils import units
import six
from manila.common import constants as const
from manila import context
from manila import exception
from manila.i18n import _
@ -135,7 +134,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
"""
def __init__(self, db, *args, **kwargs):
super(NetAppClusteredShareDriver, self).__init__(*args, **kwargs)
super(NetAppClusteredShareDriver, self).__init__(True, *args, **kwargs)
self.db = db
self._helpers = None
self._licenses = []
@ -145,7 +144,6 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
self.api_version = (1, 15)
self.backend_name = self.configuration.safe_get(
'share_backend_name') or "NetApp_Cluster_Mode"
self.mode = self.get_driver_mode(const.MULTI_SVM_MODE)
def do_setup(self, context):
"""Prepare once the driver.
@ -192,23 +190,14 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
def _update_share_stats(self):
"""Retrieve stats info from Cluster Mode backend."""
LOG.debug("Updating share stats")
data = {}
data["share_backend_name"] = self.backend_name
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'NetApp'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS_CIFS'
total, free = self._calculate_capacity()
data['total_capacity_gb'] = total / units.Gi
data['free_capacity_gb'] = free / units.Gi
data['reserved_percentage'] = 0
data['QoS_support'] = False
self._stats = data
data = dict(
share_backend_name=self.backend_name,
vendor_name='NetApp',
storage_protocol='NFS_CIFS',
total_capacity_gb=(total / units.Gi),
free_capacity_gb=(free / units.Gi))
super(NetAppClusteredShareDriver, self)._update_share_stats(data)
def check_for_setup_error(self):
"""Raises error if prerequisites are not met."""
@ -228,7 +217,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
for aggr in aggr_space_attrs])
return total, free
def setup_server(self, network_info, metadata=None):
def _setup_server(self, network_info, metadata=None):
"""Creates and configures new vserver."""
LOG.debug('Creating server %s', network_info['server_id'])
vserver_name = self._vserver_create_if_not_exists(network_info)
@ -866,7 +855,7 @@ class NetAppClusteredShareDriver(driver.ShareDriver):
self._client.send_request('vserver-destroy',
{'vserver-name': vserver_name})
def teardown_server(self, server_details, security_services=None):
def _teardown_server(self, server_details, security_services=None):
"""Teardown share network."""
vserver_name = server_details['vserver_name']
vserver_client = NetAppApiClient(

22
manila/share/drivers/zfssa/zfssashare.py
View File

@ -20,7 +20,6 @@ import base64
from oslo.config import cfg
from oslo.utils import units
from manila.common import constants as const
from manila import exception
from manila.i18n import _
from manila.i18n import _LE
@ -81,8 +80,8 @@ class ZFSSAShareDriver(driver.ShareDriver):
VERSION = '1.0.0'
PROTOCOL = 'NFS_CIFS'
def __init__(self, *args, **kwargs):
super(ZFSSAShareDriver, self).__init__(*args, **kwargs)
def __init__(self, False, *args, **kwargs):
super(ZFSSAShareDriver, self).__init__(False, *args, **kwargs)
self.configuration.append_config_values(ZFSSA_OPTS)
self.zfssa = None
self._stats = None
@ -122,7 +121,6 @@ class ZFSSAShareDriver(driver.ShareDriver):
'quota_snap': self.configuration.zfssa_nas_quota_snap,
'reservation_snap': self.configuration.zfssa_nas_quota_snap,
}
self.mode = self.get_driver_mode(const.SINGLE_SVM_MODE)
def do_setup(self, context):
"""Login, create project, no sharing option enabled."""
@ -303,14 +301,12 @@ class ZFSSAShareDriver(driver.ShareDriver):
def _update_share_stats(self):
"""Retrieve stats info from a share."""
LOG.debug("Updating share stats...")
data = {}
backend_name = self.configuration.safe_get('share_backend_name')
data["share_backend_name"] = backend_name or self.__class__.__name__
data["share_driver_mode"] = self.mode
data["vendor_name"] = 'Oracle'
data["driver_version"] = self.VERSION
data["storage_protocol"] = self.PROTOCOL
data = dict(
share_backend_name=backend_name or self.__class__.__name__,
vendor_name='Oracle',
driver_version=self.VERSION,
storage_protocol=self.PROTOCOL)
lcfg = self.configuration
(avail, used) = self.zfssa.get_pool_stats(lcfg.zfssa_pool)
@ -325,9 +321,7 @@ class ZFSSAShareDriver(driver.ShareDriver):
data['free_capacity_gb'] = 0
data['total_capacity_gb'] = 0
data['reserved_percentage'] = 0
data['QoS_support'] = False
self._stats = data
super(ZFSSAShareDriver, self)._update_share_stats(data)
def get_network_allocations_number(self):
"""Returns number of network allocations for creating VIFs."""

6
manila/share/manager.py
View File

@ -197,11 +197,11 @@ class ShareManager(manager.SchedulerDependentManager):
share_ref = self.db.share_get(context, share_id)
share_network_id = share_ref.get('share_network_id', None)
if share_network_id and self.driver.mode == constants.SINGLE_SVM_MODE:
if share_network_id and not self.driver.driver_handles_share_servers:
self.db.share_update(context, share_id, {'status': 'error'})
raise exception.ManilaException(
"Driver with single SVM mode does not expect share-network "
"to be provided.")
"Driver does not expect share-network to be provided "
"with current configuration.")
if snapshot_id is not None:
snapshot_ref = self.db.share_snapshot_get(context, snapshot_id)

17
manila/tests/fake_driver.py
View File

@ -15,7 +15,6 @@
import mock
from manila.common import constants
from manila.openstack.common import log as logging
from manila.share import driver
@ -26,10 +25,8 @@ class FakeShareDriver(driver.ShareDriver):
"""Fake share driver."""
def __init__(self, *args, **kwargs):
super(FakeShareDriver, self).__init__(execute=self.fake_execute,
*args, **kwargs)
super(FakeShareDriver, self).__init__(True, *args, **kwargs)
self.db = mock.Mock()
self.mode = constants.MULTI_SVM_MODE
def share_network_update(*args, **kwargs):
pass
@ -37,6 +34,12 @@ class FakeShareDriver(driver.ShareDriver):
self.db.share_network_update = mock.Mock(
side_effect=share_network_update)
@property
def driver_handles_share_servers(self):
if not isinstance(self.configuration.safe_get(
'driver_handles_share_servers'), bool):
return True
def create_snapshot(self, context, snapshot, share_server=None):
pass
@ -81,9 +84,3 @@ class FakeShareDriver(driver.ShareDriver):
# NOTE(vponomaryov): Simulate drivers that use share servers and
# do not use 'service_instance' module.
return 2
@staticmethod
def fake_execute(cmd, *_args, **_kwargs):
"""Execute that simply logs the command."""
LOG.debug("FAKE EXECUTE: %s", cmd)
return (None, None)

12
manila/tests/share/drivers/emc/test_driver.py
View File

@ -16,7 +16,6 @@
import mock
from stevedore import extension
from manila.common import constants as const
from manila.openstack.common import log as logging
from manila.share import configuration as conf
from manila.share.drivers.emc import driver as emcdriver
@ -29,7 +28,10 @@ LOG = logging.getLogger(__name__)
class FakeConnection(base.StorageConnection):
def __init__(self, logger):
self.logger = logger
self.supported_driver_modes = const.MULTI_SVM_MODE
@property
def driver_handles_share_servers(self):
return True
def create_share(self, emc_share_driver, context, share, share_server):
"""Is called to create share."""
@ -125,7 +127,7 @@ class EMCShareFrameworkTestCase(test.TestCase):
self.driver.plugin = mock.Mock()
self.driver._update_share_stats()
data["share_backend_name"] = FAKE_BACKEND
data["share_driver_mode"] = self.driver.mode
data["driver_handles_share_servers"] = True
data["vendor_name"] = 'EMC'
data["driver_version"] = '1.0'
data["storage_protocol"] = 'NFS_CIFS'
@ -133,9 +135,11 @@ class EMCShareFrameworkTestCase(test.TestCase):
data['free_capacity_gb'] = 'infinite'
data['reserved_percentage'] = 0
data['QoS_support'] = False
self.driver.plugin.update_share_stats.assert_called_with(data)
self.assertEqual(data, self.driver._stats)
def _fake_safe_get(self, value):
if value in ['emc_share_backend', 'share_backend_name']:
return FAKE_BACKEND
elif value == 'driver_handles_share_servers':
return True
return None

2
manila/tests/share/drivers/emc/test_emc_vnx.py
View File

@ -1650,4 +1650,6 @@ class EMCShareDriverVNXTestCase(test.TestCase):
def _fake_safe_get(self, value):
if value == "emc_share_backend":
return "vnx"
elif value == 'driver_handles_share_servers':
return True
return None

16
manila/tests/share/drivers/huawei/test_huawei_nas.py
View File

@ -25,7 +25,6 @@ import xml.dom.minidom
import mock
from oslo.serialization import jsonutils
from manila.common import constants as const
from manila import context
from manila import exception
from manila.share import configuration as conf
@ -257,7 +256,7 @@ class HuaweiShareDriverTestCase(test.TestCase):
self.configuration.safe_get = mock.Mock(side_effect=_safe_get)
self.configuration.network_config_group = 'fake_network_config_group'
self.configuration.share_backend_name = 'fake_share_backend_name'
self.configuration.share_driver_mode = const.SINGLE_SVM_MODE
self.configuration.driver_handles_share_servers = False
self.configuration.manila_huawei_conf_file = self.fake_conf_file
self.stubs.Set(time, 'sleep', fake_sleep)
driver = FakeHuaweiNasDriver(configuration=self.configuration)
@ -421,13 +420,20 @@ class HuaweiShareDriverTestCase(test.TestCase):
self.share_server)
self.assertTrue(self.driver.helper.delete_flag)
def test_get_share_stats(self):
def test_get_share_stats_refresh_false(self):
self.driver._stats = {'fake_key': 'fake_value'}
result = self.driver.get_share_stats(False)
self.assertEqual(self.driver._stats, result)
def test_get_share_stats_refresh_true(self):
self.driver.helper.login()
data = self.driver.get_share_stats()
data = self.driver.get_share_stats(True)
expected = {}
expected["share_backend_name"] = "fake_share_backend_name"
expected["share_driver_mode"] = self.driver.mode
expected["driver_handles_share_servers"] = False
expected["vendor_name"] = 'Huawei'
expected["driver_version"] = '1.0'
expected["storage_protocol"] = 'NFS_CIFS'

6
manila/tests/share/drivers/ibm/test_gpfs.py
View File

@ -79,6 +79,7 @@ class GPFSShareDriverTestCase(test.TestCase):
self._gpfs_execute = mock.Mock(return_value=('', ''))
self._helper_fake = mock.Mock()
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
self._db = mock.Mock()
self._driver = gpfs.GPFSShareDriver(self._db,
@ -140,12 +141,13 @@ class GPFSShareDriverTestCase(test.TestCase):
result = self._driver.get_share_stats(True)
expected_keys = [
'QoS_support', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
]
for key in expected_keys:
self.assertIn(key, result)
self.assertEqual(self._driver.mode, result['share_driver_mode'])
self.assertEqual(False, result['driver_handles_share_servers'])
self.assertEqual('IBM', result['vendor_name'])
self._driver._get_available_capacity.assert_called_once_with(
self._driver.configuration.gpfs_mount_point_base)

3
manila/tests/share/drivers/netapp/test_cluster_mode.py
View File

@ -34,6 +34,7 @@ class NetAppClusteredDrvTestCase(test.TestCase):
super(NetAppClusteredDrvTestCase, self).setUp()
self._context = context.get_admin_context()
self._db = mock.Mock()
driver.CONF.set_default('driver_handles_share_servers', True)
self.driver = driver.NetAppClusteredShareDriver(
self._db, configuration=configuration.Configuration(None))
self.driver._client = mock.Mock()
@ -140,7 +141,7 @@ class NetAppClusteredDrvTestCase(test.TestCase):
expected = {}
expected["share_backend_name"] = self.driver.backend_name
expected["share_driver_mode"] = self.driver.mode
expected["driver_handles_share_servers"] = True
expected["vendor_name"] = 'NetApp'
expected["driver_version"] = '1.0'
expected["storage_protocol"] = 'NFS_CIFS'

34
manila/tests/share/drivers/test_generic.py
View File

@ -88,6 +88,7 @@ class GenericShareDriverTestCase(test.TestCase):
self._helper_cifs = mock.Mock()
self._helper_nfs = mock.Mock()
CONF.set_default('driver_handles_share_servers', True)
self.fake_conf = manila.share.configuration.Configuration(None)
self._db = mock.Mock()
with mock.patch.object(
@ -944,7 +945,8 @@ class GenericShareDriverTestCase(test.TestCase):
self._driver._stats = fake_stats
expected_keys = [
'QoS_support', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
]
@ -953,37 +955,9 @@ class GenericShareDriverTestCase(test.TestCase):
self.assertNotEqual(fake_stats, result)
for key in expected_keys:
self.assertIn(key, result)
self.assertEqual(self._driver.mode, result['share_driver_mode'])
self.assertEqual(True, result['driver_handles_share_servers'])
self.assertEqual('Open Source', result['vendor_name'])
@mock.patch.object(
generic.service_instance, 'ServiceInstanceManager', mock.Mock())
def test_driver_mode_valid_value(self):
mode = const.MULTI_SVM_MODE
CONF.set_override('share_driver_mode', mode)
driver = generic.GenericShareDriver(
self._db, execute=self._execute, configuration=self.fake_conf)
self.assertEqual(mode, driver.mode)
generic.service_instance.ServiceInstanceManager.\
assert_called_once_with(self._db, driver_config=self.fake_conf)
def test_driver_mode_invalid_value(self):
mode = const.SINGLE_SVM_MODE
CONF.set_override('share_driver_mode', mode)
self.assertRaises(
exception.InvalidParameterValue,
generic.GenericShareDriver,
self._db,
execute=self._execute,
configuration=self.fake_conf)
def test_driver_mode_default_share_driver_modes(self):
mode = const.MULTI_SVM_MODE
self.assertEqual(mode, self._driver.mode)
class NFSHelperTestCase(test.TestCase):
"""Test case for NFS helper of generic driver."""

3
manila/tests/share/drivers/test_glusterfs.py
View File

@ -116,6 +116,7 @@ class GlusterfsShareDriverTestCase(test.TestCase):
CONF.set_default('glusterfs_target', '127.0.0.1:/testvol')
CONF.set_default('glusterfs_mount_point_base', '/mnt/nfs')
CONF.set_default('reserved_share_percentage', 50)
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
self._db = mock.Mock()
@ -447,7 +448,7 @@ class GlusterfsShareDriverTestCase(test.TestCase):
def test_update_share_stats(self):
test_data = {
'share_backend_name': 'GlusterFS',
'share_driver_mode': self._driver.mode,
'driver_handles_share_servers': False,
'vendor_name': 'Red Hat',
'driver_version': '1.0',
'storage_protocol': 'NFS',

3
manila/tests/share/drivers/test_glusterfs_native.py
View File

@ -85,6 +85,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase):
self.gluster_target2 = 'root@host2:/gv2'
CONF.set_default('glusterfs_targets',
[self.gluster_target1, self.gluster_target2])
CONF.set_default('driver_handles_share_servers', False)
self.fake_conf = config.Configuration(None)
self._db = mock.Mock()
@ -792,7 +793,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase):
def test_update_share_stats(self):
test_data = {
'share_backend_name': 'GlusterFS-Native',
'share_driver_mode': self._driver.mode,
'driver_handles_share_servers': False,
'vendor_name': 'Red Hat',
'driver_version': '1.1',
'storage_protocol': 'glusterfs',

5
manila/tests/share/drivers/zfssa/test_zfssashare.py
View File

@ -17,7 +17,6 @@ Unit tests for Oracle's ZFSSA Manila driver.
import mock
from oslo.config import cfg
from manila.common import constants as const
from manila import context
from manila import exception
from manila.share import configuration as conf
@ -67,7 +66,7 @@ class ZFSSAShareDriverTestCase(test.TestCase):
_factory_zfssa.set_host(lcfg.zfssa_host)
_factory_zfssa.login(lcfg.zfssa_auth_user)
self._context = context.get_admin_context()
self._driver = zfssashare.ZFSSAShareDriver(configuration=lcfg)
self._driver = zfssashare.ZFSSAShareDriver(False, configuration=lcfg)
self._driver.do_setup(self._context)
def _create_fake_config(self):
@ -91,7 +90,7 @@ class ZFSSAShareDriverTestCase(test.TestCase):
self.configuration.zfssa_nas_quota_snap = 'true'
self.configuration.zfssa_rest_timeout = 60
self.configuration.network_config_group = 'fake_network_config_group'
self.configuration.share_driver_mode = const.SINGLE_SVM_MODE
self.configuration.driver_handles_share_servers = False
def test_create_share(self):
self.stubs.Set(self._driver.zfssa, 'create_share', mock.Mock())

129
manila/tests/share/test_driver.py
View File

@ -21,7 +21,6 @@ import time
import ddt
import mock
from manila.common import constants
from manila import exception
from manila import network
from manila.share import configuration
@ -51,22 +50,20 @@ class ShareDriverTestCase(test.TestCase):
self.stubs.Set(self.utils, 'execute', fake_execute_with_raise)
self.time = time
self.stubs.Set(self.time, 'sleep', fake_sleep)
self.fake_valid_modes = ('v1', 'v2', )
self.stubs.Set(
constants, 'VALID_SHARE_DRIVER_MODES', self.fake_valid_modes)
self.stubs.Set(driver.CONF, 'driver_handles_share_servers', True)
def test__try_execute(self):
execute_mixin = ShareDriverWithExecuteMixin(
configuration=configuration.Configuration(None))
True, configuration=configuration.Configuration(None))
self.assertRaises(exception.ProcessExecutionError,
execute_mixin._try_execute)
def test_verify_share_driver_mode_option_type(self):
opt_name = 'driver_handles_share_servers'
with utils.tempdir() as tmpdir:
tmpfilename = os.path.join(tmpdir, 'share_driver_mode.conf')
tmpfilename = os.path.join(tmpdir, '%s.conf' % opt_name)
with open(tmpfilename, "w") as configfile:
configfile.write("""[DEFAULT]\nshare_driver_mode = fake""")
configfile.write("""[DEFAULT]\n%s = True""" % opt_name)
# Add config file with updated opt
driver.CONF.default_config_files = [configfile.name]
@ -74,17 +71,19 @@ class ShareDriverTestCase(test.TestCase):
# Reload config instance to use redefined opt
driver.CONF.reload_config_files()
share_driver = driver.ShareDriver()
self.assertEqual('fake', share_driver.mode)
share_driver = driver.ShareDriver([True, False])
self.assertEqual(True, share_driver.driver_handles_share_servers)
def _instantiate_share_driver(self, network_config_group):
def _instantiate_share_driver(self, network_config_group,
driver_handles_share_servers):
self.stubs.Set(network, 'API', mock.Mock())
config = mock.Mock()
config.append_config_values = mock.Mock()
config.config_group = 'fake_config_group'
config.network_config_group = network_config_group
config.safe_get = mock.Mock(return_value=driver_handles_share_servers)
share_driver = driver.ShareDriver(configuration=config)
share_driver = driver.ShareDriver([True, False], configuration=config)
self.assertTrue(hasattr(share_driver, 'configuration'))
config.append_config_values.assert_called_once_with(driver.share_opts)
@ -94,25 +93,24 @@ class ShareDriverTestCase(test.TestCase):
else:
network.API.assert_called_once_with(
config_group_name=config.config_group)
self.assertTrue(hasattr(share_driver, 'mode'))
return share_driver
def test_instantiate_share_driver(self):
self._instantiate_share_driver(None)
self._instantiate_share_driver(None, True)
def test_instantiate_share_driver_another_config_group(self):
self._instantiate_share_driver("fake_network_config_group")
self._instantiate_share_driver("fake_network_config_group", True)
def test_instantiate_share_driver_no_configuration(self):
self.stubs.Set(network, 'API', mock.Mock())
share_driver = driver.ShareDriver(configuration=None)
share_driver = driver.ShareDriver(True, configuration=None)
self.assertEqual(None, share_driver.configuration)
network.API.assert_called_once_with(config_group_name=None)
def test_get_share_stats_refresh_false(self):
share_driver = driver.ShareDriver(configuration=None)
share_driver = driver.ShareDriver(True, configuration=None)
share_driver._stats = {'fake_key': 'fake_value'}
result = share_driver.get_share_stats(False)
@ -123,10 +121,11 @@ class ShareDriverTestCase(test.TestCase):
conf = configuration.Configuration(None)
expected_keys = [
'QoS_support', 'driver_version', 'share_backend_name',
'free_capacity_gb', 'share_driver_mode', 'total_capacity_gb',
'free_capacity_gb', 'total_capacity_gb',
'driver_handles_share_servers',
'reserved_percentage', 'vendor_name', 'storage_protocol',
]
share_driver = driver.ShareDriver(configuration=conf)
share_driver = driver.ShareDriver(True, configuration=conf)
fake_stats = {'fake_key': 'fake_value'}
share_driver._stats = fake_stats
@ -138,53 +137,61 @@ class ShareDriverTestCase(test.TestCase):
self.assertEqual('Open Source', result['vendor_name'])
@ddt.data(
'', 'v1', 'v2', 'fake1', None,
[], ['v1'], ['v2'], ['v1', 'v2'], ['fake1'], ['fake1', 'fake2'],
(), ('v1'), ('v2'), ('v1', 'v2'), ('fake1', ), ('fake1', 'fake2'))
def test_get_driver_mode_invalid_opt(self, driver_modes):
share_driver = self._instantiate_share_driver(None)
share_driver.mode = 'fake'
self.assertRaises(
exception.InvalidParameterValue,
share_driver.get_driver_mode, driver_modes)
{'opt': True, 'allowed': True},
{'opt': True, 'allowed': (True, False)},
{'opt': True, 'allowed': [True, False]},
{'opt': True, 'allowed': set([True, False])},
{'opt': False, 'allowed': False},
{'opt': False, 'allowed': (True, False)},
{'opt': False, 'allowed': [True, False]},
{'opt': False, 'allowed': set([True, False])})
@ddt.unpack
def test__verify_share_server_handling_valid_cases(self, opt, allowed):
conf = configuration.Configuration(None)
self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt))
share_driver = driver.ShareDriver(allowed, configuration=conf)
self.assertTrue(conf.safe_get.celled)
self.assertEqual(opt, share_driver.driver_handles_share_servers)
@ddt.data(
(), [], ('v1', 'v2'), ['v1', 'v2'], ('v1', 'fake1'), ['v1', 'fake1'],
('fake1', 'fake2'), ['fake1', 'fake2'], ('fake1', ), ['fake1'], '',
'fake1', {}, {'v1': 'v2'}, None)
def test_get_driver_mode_none_opt_invalid_cases(self, driver_modes):
share_driver = self._instantiate_share_driver(None)
share_driver.mode = None
{'opt': False, 'allowed': True},
{'opt': True, 'allowed': False},
{'opt': None, 'allowed': True},
{'opt': 'True', 'allowed': True},
{'opt': 'False', 'allowed': False},
{'opt': [], 'allowed': True},
{'opt': True, 'allowed': []},
{'opt': True, 'allowed': ['True']},
{'opt': False, 'allowed': ['False']})
@ddt.unpack
def test__verify_share_server_handling_invalid_cases(self, opt, allowed):
conf = configuration.Configuration(None)
self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt))
self.assertRaises(
exception.InvalidParameterValue,
share_driver.get_driver_mode, driver_modes)
exception.ManilaException,
driver.ShareDriver, allowed, configuration=conf)
self.assertTrue(conf.safe_get.celled)
@ddt.data('v2', ('v2', ), ['v2', ])
def test_get_driver_mode_none_opt_valid_cases(self, driver_modes):
share_driver = self._instantiate_share_driver(None)
share_driver.mode = None
def test_setup_server_handling_disabled(self):
share_driver = self._instantiate_share_driver(None, False)
# We expect successful execution, nothing to assert
share_driver.setup_server('Nothing is expected to happen.')
mode = share_driver.get_driver_mode(driver_modes)
self.assertEqual('v2', mode)
@ddt.data(
(), [], '', 'fake1', 'v1', ('v1', ), ['v1'], {}, {'v1': 'v2'}, None,
('fake1', ), ['fake2'], ['fake1', 'fake2'], ('fake2', 'fake1'))
def test_get_driver_mode_valid_opt_invalid_cases(self, driver_modes):
share_driver = self._instantiate_share_driver(None)
share_driver.mode = 'v2'
def test_setup_server_handling_enabled(self):
share_driver = self._instantiate_share_driver(None, True)
self.assertRaises(
exception.InvalidParameterValue,
share_driver.get_driver_mode, driver_modes)
NotImplementedError,
share_driver.setup_server,
'fake_network_info')
@ddt.data(
'v2', ('v2', ), ['v2'], ('v2', 'v1'), ['v2', 'v1'],
('v2', 'fake2'), ['v2', 'fake1'])
def test_get_driver_mode_valid_opt_valid_cases(self, driver_modes):
share_driver = self._instantiate_share_driver(None)
share_driver.mode = 'v2'
def test_teardown_server_handling_disabled(self):
share_driver = self._instantiate_share_driver(None, False)
# We expect successful execution, nothing to assert
share_driver.teardown_server('Nothing is expected to happen.')
mode = share_driver.get_driver_mode(driver_modes)
self.assertEqual('v2', mode)
def test_teardown_server_handling_enabled(self):
share_driver = self._instantiate_share_driver(None, True)
self.assertRaises(
NotImplementedError,
share_driver.teardown_server,
'fake_share_server_details')

8
manila/tests/share/test_manager.py
View File

@ -460,7 +460,11 @@ class ShareManagerTestCase(test.TestCase):
utils.IsAMatcher(models.ShareSnapshot),
share_server=None)
def test_create_share_with_share_network_using_single_svm_driver(self):
def test_create_share_with_share_network_driver_not_handles_servers(self):
manager.CONF.set_default('driver_handles_share_servers', False)
self.stubs.Set(
self.share_manager.driver.configuration, 'safe_get',
mock.Mock(return_value=False))
share_id = 'fake_share_id'
share_network_id = 'fake_sn'
self.stubs.Set(
@ -468,8 +472,6 @@ class ShareManagerTestCase(test.TestCase):
mock.Mock(return_value=self._create_share(
share_network_id=share_network_id)))
self.stubs.Set(self.share_manager.db, 'share_update', mock.Mock())
self.stubs.Set(
self.share_manager.driver, 'mode', constants.SINGLE_SVM_MODE)
self.assertRaises(
exception.ManilaException,