278 lines
11 KiB
Python
278 lines
11 KiB
Python
# Copyright (c) 2014 Huawei Technologies Co., Ltd.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
"""Huawei Nas Driver for Huawei storage arrays."""
|
|
from xml.etree import ElementTree as ET
|
|
|
|
from oslo_config import cfg
|
|
from oslo_log import log
|
|
from oslo_utils import importutils
|
|
|
|
from manila import exception
|
|
from manila.i18n import _
|
|
from manila.share import driver
|
|
|
|
|
|
HUAWEI_UNIFIED_DRIVER_REGISTRY = {
|
|
'V3': 'manila.share.drivers.huawei.v3.connection.V3StorageConnection', }
|
|
|
|
|
|
huawei_opts = [
|
|
cfg.StrOpt('manila_huawei_conf_file',
|
|
default='/etc/manila/manila_huawei_conf.xml',
|
|
help='The configuration file for the Manila Huawei driver.')]
|
|
|
|
CONF = cfg.CONF
|
|
CONF.register_opts(huawei_opts)
|
|
LOG = log.getLogger(__name__)
|
|
|
|
|
|
class HuaweiNasDriver(driver.ShareDriver):
|
|
"""Huawei Share Driver.
|
|
|
|
Executes commands relating to Shares.
|
|
Driver version history::
|
|
|
|
1.0 - Initial version.
|
|
1.1 - Add shrink share.
|
|
Add extend share.
|
|
Add manage share.
|
|
Add share level(ro).
|
|
Add smartx capabilities.
|
|
Support multi pools in one backend.
|
|
1.2 - Add share server support.
|
|
Add ensure share.
|
|
Add QoS support.
|
|
Add create share from snapshot.
|
|
1.3 - Add manage snapshot.
|
|
Support reporting disk type of pool.
|
|
Add replication support.
|
|
"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""Do initialization."""
|
|
LOG.debug("Enter into init function of Huawei Driver.")
|
|
super(HuaweiNasDriver, self).__init__((True, False), *args, **kwargs)
|
|
|
|
if not self.configuration:
|
|
raise exception.InvalidInput(reason=_(
|
|
"Huawei driver configuration missing."))
|
|
|
|
self.configuration.append_config_values(huawei_opts)
|
|
kwargs.pop('configuration')
|
|
self.plugin = importutils.import_object(self.get_backend_driver(),
|
|
self.configuration,
|
|
**kwargs)
|
|
|
|
def check_for_setup_error(self):
|
|
"""Returns an error if prerequisites aren't met."""
|
|
self.plugin.check_conf_file()
|
|
self.plugin.check_service()
|
|
|
|
def get_backend_driver(self):
|
|
filename = self.configuration.manila_huawei_conf_file
|
|
|
|
try:
|
|
tree = ET.parse(filename)
|
|
root = tree.getroot()
|
|
except Exception as err:
|
|
message = (_('Read Huawei config file(%(filename)s)'
|
|
' for Manila error: %(err)s')
|
|
% {'filename': filename,
|
|
'err': err})
|
|
LOG.error(message)
|
|
raise exception.InvalidInput(reason=message)
|
|
product = root.findtext('Storage/Product')
|
|
backend_driver = HUAWEI_UNIFIED_DRIVER_REGISTRY.get(product)
|
|
if backend_driver is None:
|
|
raise exception.InvalidInput(
|
|
reason=_('Product %s is not supported. Product '
|
|
'must be set to V3.') % product)
|
|
|
|
return backend_driver
|
|
|
|
def do_setup(self, context):
|
|
"""Any initialization the huawei nas driver does while starting."""
|
|
LOG.debug("Do setup the plugin.")
|
|
self.plugin.connect()
|
|
|
|
def create_share(self, context, share, share_server=None):
|
|
"""Create a share."""
|
|
LOG.debug("Create a share.")
|
|
location = self.plugin.create_share(share, share_server)
|
|
return location
|
|
|
|
def extend_share(self, share, new_size, share_server=None):
|
|
LOG.debug("Extend a share.")
|
|
self.plugin.extend_share(share, new_size, share_server)
|
|
|
|
def create_share_from_snapshot(self, context, share, snapshot,
|
|
share_server=None, parent_share=None):
|
|
"""Create a share from snapshot."""
|
|
LOG.debug("Create a share from snapshot %s.", snapshot['snapshot_id'])
|
|
location = self.plugin.create_share_from_snapshot(share, snapshot)
|
|
return location
|
|
|
|
def shrink_share(self, share, new_size, share_server=None):
|
|
"""Shrinks size of existing share."""
|
|
LOG.debug("Shrink a share.")
|
|
self.plugin.shrink_share(share, new_size, share_server)
|
|
|
|
def delete_share(self, context, share, share_server=None):
|
|
"""Delete a share."""
|
|
LOG.debug("Delete a share.")
|
|
self.plugin.delete_share(share, share_server)
|
|
|
|
def create_snapshot(self, context, snapshot, share_server=None):
|
|
"""Create a snapshot."""
|
|
LOG.debug("Create a snapshot.")
|
|
snapshot_name = self.plugin.create_snapshot(snapshot, share_server)
|
|
return {'provider_location': snapshot_name}
|
|
|
|
def delete_snapshot(self, context, snapshot, share_server=None):
|
|
"""Delete a snapshot."""
|
|
LOG.debug("Delete a snapshot.")
|
|
self.plugin.delete_snapshot(snapshot, share_server)
|
|
|
|
def ensure_share(self, context, share, share_server=None):
|
|
"""Ensure that share is exported."""
|
|
LOG.debug("Ensure share.")
|
|
location = self.plugin.ensure_share(share, share_server)
|
|
return location
|
|
|
|
def allow_access(self, context, share, access, share_server=None):
|
|
"""Allow access to the share."""
|
|
LOG.debug("Allow access.")
|
|
self.plugin.allow_access(share, access, share_server)
|
|
|
|
def deny_access(self, context, share, access, share_server=None):
|
|
"""Deny access to the share."""
|
|
LOG.debug("Deny access.")
|
|
self.plugin.deny_access(share, access, share_server)
|
|
|
|
def update_access(self, context, share, access_rules, add_rules,
|
|
delete_rules, share_server=None):
|
|
"""Update access rules list."""
|
|
LOG.debug("Update access.")
|
|
self.plugin.update_access(share, access_rules,
|
|
add_rules, delete_rules, share_server)
|
|
|
|
def get_pool(self, share):
|
|
"""Return pool name where the share resides on."""
|
|
LOG.debug("Get pool.")
|
|
return self.plugin.get_pool(share)
|
|
|
|
def get_network_allocations_number(self):
|
|
"""Get number of network interfaces to be created."""
|
|
LOG.debug("Get network allocations number.")
|
|
return self.plugin.get_network_allocations_number()
|
|
|
|
def manage_existing(self, share, driver_options):
|
|
"""Manage existing share."""
|
|
LOG.debug("Manage existing share to manila.")
|
|
share_size, location = self.plugin.manage_existing(share,
|
|
driver_options)
|
|
return {'size': share_size, 'export_locations': location}
|
|
|
|
def manage_existing_snapshot(self, snapshot, driver_options):
|
|
"""Manage existing snapshot."""
|
|
LOG.debug("Manage existing snapshot to manila.")
|
|
snapshot_name = self.plugin.manage_existing_snapshot(snapshot,
|
|
driver_options)
|
|
return {'provider_location': snapshot_name}
|
|
|
|
def _update_share_stats(self):
|
|
"""Retrieve status info from share group."""
|
|
|
|
backend_name = self.configuration.safe_get('share_backend_name')
|
|
data = dict(
|
|
share_backend_name=backend_name or 'HUAWEI_NAS_Driver',
|
|
vendor_name='Huawei',
|
|
driver_version='1.3',
|
|
storage_protocol='NFS_CIFS',
|
|
qos=True,
|
|
total_capacity_gb=0.0,
|
|
free_capacity_gb=0.0,
|
|
snapshot_support=self.plugin.snapshot_support,
|
|
create_share_from_snapshot_support=self.plugin.snapshot_support,
|
|
revert_to_snapshot_support=self.plugin.snapshot_support,
|
|
)
|
|
|
|
# huawei array doesn't support snapshot replication, so driver can't
|
|
# create replicated snapshot, this's not fit the requirement of
|
|
# replication feature.
|
|
# to avoid this problem, we specify huawei driver can't support
|
|
# snapshot and replication both, as a workaround.
|
|
if not data['snapshot_support'] and self.plugin.replication_support:
|
|
data['replication_type'] = 'dr'
|
|
|
|
self.plugin.update_share_stats(data)
|
|
super(HuaweiNasDriver, self)._update_share_stats(data)
|
|
|
|
def _setup_server(self, network_info, metadata=None):
|
|
"""Set up share server with given network parameters."""
|
|
return self.plugin.setup_server(network_info, metadata)
|
|
|
|
def _teardown_server(self, server_details, security_services=None):
|
|
"""Teardown share server."""
|
|
return self.plugin.teardown_server(server_details, security_services)
|
|
|
|
def create_replica(self, context, replica_list, new_replica,
|
|
access_rules, replica_snapshots, share_server=None):
|
|
"""Replicate the active replica to a new replica on this backend."""
|
|
return self.plugin.create_replica(context,
|
|
replica_list,
|
|
new_replica,
|
|
access_rules,
|
|
replica_snapshots,
|
|
share_server)
|
|
|
|
def update_replica_state(self, context, replica_list, replica,
|
|
access_rules, replica_snapshots,
|
|
share_server=None):
|
|
"""Update the replica_state of a replica."""
|
|
return self.plugin.update_replica_state(context,
|
|
replica_list,
|
|
replica,
|
|
access_rules,
|
|
replica_snapshots,
|
|
share_server)
|
|
|
|
def promote_replica(self, context, replica_list, replica, access_rules,
|
|
share_server=None):
|
|
"""Promote a replica to 'active' replica state.."""
|
|
return self.plugin.promote_replica(context,
|
|
replica_list,
|
|
replica,
|
|
access_rules,
|
|
share_server)
|
|
|
|
def delete_replica(self, context, replica_list, replica_snapshots,
|
|
replica, share_server=None):
|
|
"""Delete a replica."""
|
|
self.plugin.delete_replica(context,
|
|
replica_list,
|
|
replica_snapshots,
|
|
replica,
|
|
share_server)
|
|
|
|
def revert_to_snapshot(self, context, snapshot, share_access_rules,
|
|
snapshot_access_rules, share_server=None):
|
|
self.plugin.revert_to_snapshot(context,
|
|
snapshot,
|
|
share_access_rules,
|
|
snapshot_access_rules,
|
|
share_server)
|