330 lines
12 KiB
Python
330 lines
12 KiB
Python
# Copyright (C) 2020, 2023, Hitachi, Ltd.
|
|
#
|
|
# 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.
|
|
#
|
|
"""Fibre channel module for Hitachi HBSD Driver."""
|
|
|
|
import os
|
|
|
|
from oslo_utils import excutils
|
|
|
|
from cinder import interface
|
|
from cinder.volume import driver
|
|
from cinder.volume.drivers.hitachi import hbsd_common as common
|
|
from cinder.volume.drivers.hitachi import hbsd_replication as replication
|
|
from cinder.volume.drivers.hitachi import hbsd_rest as rest
|
|
from cinder.volume.drivers.hitachi import hbsd_rest_fc as rest_fc
|
|
from cinder.volume.drivers.hitachi import hbsd_utils as utils
|
|
from cinder.volume import volume_utils
|
|
|
|
MSG = utils.HBSDMsg
|
|
|
|
_DRIVER_INFO = {
|
|
'version': utils.VERSION,
|
|
'proto': 'FC',
|
|
'hba_id': 'wwpns',
|
|
'hba_id_type': 'World Wide Name',
|
|
'msg_id': {
|
|
'target': MSG.CREATE_HOST_GROUP_FAILED,
|
|
},
|
|
'volume_backend_name': '%(prefix)sFC' % {
|
|
'prefix': utils.DRIVER_PREFIX,
|
|
},
|
|
'volume_type': 'fibre_channel',
|
|
'param_prefix': utils.PARAM_PREFIX,
|
|
'vendor_name': utils.VENDOR_NAME,
|
|
'driver_dir_name': utils.DRIVER_DIR_NAME,
|
|
'driver_prefix': utils.DRIVER_PREFIX,
|
|
'driver_file_prefix': utils.DRIVER_FILE_PREFIX,
|
|
'target_prefix': utils.TARGET_PREFIX,
|
|
'hdp_vol_attr': utils.HDP_VOL_ATTR,
|
|
'hdt_vol_attr': utils.HDT_VOL_ATTR,
|
|
'nvol_ldev_type': utils.NVOL_LDEV_TYPE,
|
|
'target_iqn_suffix': utils.TARGET_IQN_SUFFIX,
|
|
'pair_attr': utils.PAIR_ATTR,
|
|
'mirror_attr': utils.MIRROR_ATTR,
|
|
'driver_impl_class': rest_fc.HBSDRESTFC,
|
|
}
|
|
|
|
|
|
@interface.volumedriver
|
|
class HBSDFCDriver(driver.FibreChannelDriver):
|
|
"""Fibre channel class for Hitachi HBSD Driver.
|
|
|
|
Version history:
|
|
|
|
.. code-block:: none
|
|
|
|
1.0.0 - Initial driver.
|
|
1.1.0 - Add manage_existing/manage_existing_get_size/unmanage methods
|
|
2.0.0 - Major redesign of the driver. This version requires the REST
|
|
API for communication with the storage backend.
|
|
2.1.0 - Add Cinder generic volume groups.
|
|
2.2.0 - Add maintenance parameters.
|
|
2.2.1 - Make the parameters name variable for supporting OEM storages.
|
|
2.2.2 - Add Target Port Assignment.
|
|
2.2.3 - Add port scheduler.
|
|
2.3.0 - Support multi pool.
|
|
2.3.1 - Update retype and support storage assisted migration.
|
|
2.3.2 - Add specifies format of the names HostGroups/iSCSI Targets.
|
|
2.3.3 - Add GAD volume support.
|
|
2.3.4 - Support data deduplication and compression.
|
|
2.3.5 - Fix key error when backend is down.
|
|
|
|
"""
|
|
|
|
VERSION = utils.VERSION
|
|
|
|
# ThirdPartySystems wiki page
|
|
CI_WIKI_NAME = utils.CI_WIKI_NAME
|
|
|
|
driver_info = dict(_DRIVER_INFO)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
"""Initialize instance variables."""
|
|
utils.output_log(MSG.DRIVER_INITIALIZATION_START,
|
|
driver=self.__class__.__name__,
|
|
version=self.get_version())
|
|
super(HBSDFCDriver, self).__init__(*args, **kwargs)
|
|
|
|
self.configuration.append_config_values(common.COMMON_VOLUME_OPTS)
|
|
self.configuration.append_config_values(common.COMMON_PAIR_OPTS)
|
|
self.configuration.append_config_values(common.COMMON_PORT_OPTS)
|
|
self.configuration.append_config_values(common.COMMON_NAME_OPTS)
|
|
self.configuration.append_config_values(rest_fc.FC_VOLUME_OPTS)
|
|
self.configuration.append_config_values(
|
|
replication.COMMON_MIRROR_OPTS)
|
|
os.environ['LANG'] = 'C'
|
|
kwargs.setdefault('driver_info', _DRIVER_INFO)
|
|
self.driver_info = dict(kwargs['driver_info'])
|
|
self.driver_info['driver_class'] = self.__class__
|
|
if self.configuration.safe_get('hitachi_mirror_storage_id'):
|
|
self.common = replication.HBSDREPLICATION(
|
|
self.configuration, self.driver_info, kwargs.get('db'))
|
|
elif not hasattr(self, '_init_common'):
|
|
self.common = self.driver_info['driver_impl_class'](
|
|
self.configuration, self.driver_info, kwargs.get('db'))
|
|
else:
|
|
self.common = self._init_common(
|
|
self.configuration, kwargs.get('db'))
|
|
|
|
@staticmethod
|
|
def get_driver_options():
|
|
additional_opts = HBSDFCDriver._get_oslo_driver_opts(
|
|
*(common._INHERITED_VOLUME_OPTS +
|
|
rest._REQUIRED_REST_OPTS +
|
|
['driver_ssl_cert_verify', 'driver_ssl_cert_path',
|
|
'san_api_port', ]))
|
|
return (common.COMMON_VOLUME_OPTS +
|
|
common.COMMON_PORT_OPTS +
|
|
common.COMMON_PAIR_OPTS +
|
|
common.COMMON_NAME_OPTS +
|
|
rest.REST_VOLUME_OPTS +
|
|
rest.REST_PAIR_OPTS +
|
|
rest_fc.FC_VOLUME_OPTS +
|
|
replication._REP_OPTS +
|
|
replication.COMMON_MIRROR_OPTS +
|
|
replication.ISCSI_MIRROR_OPTS +
|
|
replication.REST_MIRROR_OPTS +
|
|
replication.REST_MIRROR_API_OPTS +
|
|
replication.REST_MIRROR_SSL_OPTS +
|
|
additional_opts)
|
|
|
|
def check_for_setup_error(self):
|
|
pass
|
|
|
|
@volume_utils.trace
|
|
def create_volume(self, volume):
|
|
"""Create a volume and return its properties."""
|
|
return self.common.create_volume(volume)
|
|
|
|
@volume_utils.trace
|
|
def create_volume_from_snapshot(self, volume, snapshot):
|
|
"""Create a volume from a snapshot and return its properties."""
|
|
return self.common.create_volume_from_snapshot(volume, snapshot)
|
|
|
|
@volume_utils.trace
|
|
def create_cloned_volume(self, volume, src_vref):
|
|
"""Create a clone of the specified volume and return its properties."""
|
|
return self.common.create_cloned_volume(volume, src_vref)
|
|
|
|
@volume_utils.trace
|
|
def delete_volume(self, volume):
|
|
"""Delete the specified volume."""
|
|
self.common.delete_volume(volume)
|
|
|
|
@volume_utils.trace
|
|
def create_snapshot(self, snapshot):
|
|
"""Create a snapshot from a volume and return its properties."""
|
|
return self.common.create_snapshot(snapshot)
|
|
|
|
@volume_utils.trace
|
|
def delete_snapshot(self, snapshot):
|
|
"""Delete the specified snapshot."""
|
|
self.common.delete_snapshot(snapshot)
|
|
|
|
def local_path(self, volume):
|
|
pass
|
|
|
|
def _update_volume_stats(self):
|
|
"""Return properties, capabilities and current states of the driver."""
|
|
data = self.common.update_volume_stats()
|
|
if 'pools' in data:
|
|
for pool in data['pools']:
|
|
pool["filter_function"] = self.get_filter_function()
|
|
pool["goodness_function"] = (
|
|
self.get_goodness_function())
|
|
self._stats = data
|
|
|
|
@volume_utils.trace
|
|
def update_migrated_volume(
|
|
self, ctxt, volume, new_volume, original_volume_status):
|
|
"""Do any remaining jobs after migration."""
|
|
self.common.discard_zero_page(new_volume)
|
|
super(HBSDFCDriver, self).update_migrated_volume(
|
|
ctxt, volume, new_volume, original_volume_status)
|
|
|
|
@volume_utils.trace
|
|
def copy_image_to_volume(self, context, volume, image_service, image_id,
|
|
disable_sparse=False):
|
|
"""Fetch the image from image_service and write it to the volume."""
|
|
super(HBSDFCDriver, self).copy_image_to_volume(
|
|
context, volume, image_service, image_id,
|
|
disable_sparse=disable_sparse)
|
|
self.common.discard_zero_page(volume)
|
|
|
|
@volume_utils.trace
|
|
def extend_volume(self, volume, new_size):
|
|
"""Extend the specified volume to the specified size."""
|
|
self.common.extend_volume(volume, new_size)
|
|
|
|
@volume_utils.trace
|
|
def manage_existing(self, volume, existing_ref):
|
|
"""Return volume properties which Cinder needs to manage the volume."""
|
|
return self.common.manage_existing(volume, existing_ref)
|
|
|
|
@volume_utils.trace
|
|
def manage_existing_get_size(self, volume, existing_ref):
|
|
"""Return the size[GB] of the specified volume."""
|
|
return self.common.manage_existing_get_size(volume, existing_ref)
|
|
|
|
@volume_utils.trace
|
|
def unmanage(self, volume):
|
|
"""Prepare the volume for removing it from Cinder management."""
|
|
self.common.unmanage(volume)
|
|
|
|
@volume_utils.trace
|
|
def do_setup(self, context):
|
|
"""Prepare for the startup of the driver."""
|
|
self.common.do_setup(context)
|
|
|
|
def ensure_export(self, context, volume):
|
|
"""Synchronously recreate an export for a volume."""
|
|
pass
|
|
|
|
def create_export(self, context, volume, connector):
|
|
"""Export the volume."""
|
|
pass
|
|
|
|
def remove_export(self, context, volume):
|
|
"""Remove an export for a volume."""
|
|
pass
|
|
|
|
def create_export_snapshot(self, context, snapshot, connector):
|
|
pass
|
|
|
|
def remove_export_snapshot(self, context, snapshot):
|
|
pass
|
|
|
|
@volume_utils.trace
|
|
def initialize_connection(self, volume, connector):
|
|
"""Initialize connection between the server and the volume."""
|
|
return self.common.initialize_connection(volume, connector)
|
|
|
|
@volume_utils.trace
|
|
def terminate_connection(self, volume, connector, **kwargs):
|
|
"""Terminate connection between the server and the volume."""
|
|
if connector is None:
|
|
connector = {}
|
|
if utils.is_shared_connection(volume, connector):
|
|
return
|
|
self.common.terminate_connection(volume, connector)
|
|
|
|
@volume_utils.trace
|
|
def initialize_connection_snapshot(self, snapshot, connector, **kwargs):
|
|
"""Initialize connection between the server and the snapshot."""
|
|
return self.common.initialize_connection(
|
|
snapshot, connector, is_snapshot=True)
|
|
|
|
@volume_utils.trace
|
|
def terminate_connection_snapshot(self, snapshot, connector, **kwargs):
|
|
"""Terminate connection between the server and the snapshot."""
|
|
self.common.terminate_connection(snapshot, connector)
|
|
|
|
@volume_utils.trace
|
|
def unmanage_snapshot(self, snapshot):
|
|
"""Prepare the snapshot for removing it from Cinder management."""
|
|
return self.common.unmanage_snapshot(snapshot)
|
|
|
|
@volume_utils.trace
|
|
def retype(self, ctxt, volume, new_type, diff, host):
|
|
"""Retype the specified volume."""
|
|
return self.common.retype(ctxt, volume, new_type, diff, host)
|
|
|
|
@volume_utils.trace
|
|
def migrate_volume(self, ctxt, volume, host):
|
|
"""Migrate the specified volume."""
|
|
return self.common.migrate_volume(volume, host)
|
|
|
|
def backup_use_temp_snapshot(self):
|
|
return True
|
|
|
|
@volume_utils.trace
|
|
def revert_to_snapshot(self, context, volume, snapshot):
|
|
"""Rollback the specified snapshot"""
|
|
return self.common.revert_to_snapshot(volume, snapshot)
|
|
|
|
@volume_utils.trace
|
|
def create_group(self, context, group):
|
|
return self.common.create_group()
|
|
|
|
@volume_utils.trace
|
|
def delete_group(self, context, group, volumes):
|
|
return self.common.delete_group(group, volumes)
|
|
|
|
@volume_utils.trace
|
|
def create_group_from_src(
|
|
self, context, group, volumes, group_snapshot=None, snapshots=None,
|
|
source_group=None, source_vols=None):
|
|
return self.common.create_group_from_src(
|
|
context, group, volumes, snapshots, source_vols)
|
|
|
|
@volume_utils.trace
|
|
def update_group(
|
|
self, context, group, add_volumes=None, remove_volumes=None):
|
|
try:
|
|
return self.common.update_group(group, add_volumes)
|
|
except Exception:
|
|
with excutils.save_and_reraise_exception():
|
|
for remove_volume in remove_volumes:
|
|
utils.cleanup_cg_in_volume(remove_volume)
|
|
|
|
@volume_utils.trace
|
|
def create_group_snapshot(self, context, group_snapshot, snapshots):
|
|
return self.common.create_group_snapshot(
|
|
context, group_snapshot, snapshots)
|
|
|
|
@volume_utils.trace
|
|
def delete_group_snapshot(self, context, group_snapshot, snapshots):
|
|
return self.common.delete_group_snapshot(group_snapshot, snapshots)
|