Shared filesystem management project for OpenStack.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

623 lines
21 KiB

# Copyright 2019 Inspur Corp.
# 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
# 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.
Driver for Inspur InStorage
import ipaddress
import itertools
import six
from oslo_config import cfg
from oslo_log import log
from oslo_utils import units
from manila import coordination
from manila import exception
from manila.i18n import _
from manila.share import driver
from manila.share import utils as share_utils
from manila.share.drivers.inspur.instorage.cli_helper import InStorageSSH
from manila.share.drivers.inspur.instorage.cli_helper import SSHRunner
instorage_opts = [
help='IP address for the InStorage.'
help='Port number for the InStorage.'
help='Username for the InStorage.'
help='Password for the InStorage.'
help='The Storage Pools Manila should use, a comma separated list.'
LOG = log.getLogger(__name__)
class InStorageShareDriver(driver.ShareDriver):
"""Inspur InStorage NAS driver. Allows for NFS and CIFS NAS.
.. code::none
Version history:
1.0.0 - Initial driver.
Driver support:
share create/delete
extend size
protocol: NFS/CIFS
VERSION = '1.0.0'
def __init__(self, *args, **kwargs):
super(InStorageShareDriver, self).__init__(False, *args, **kwargs)
self.backend_name = self.configuration.safe_get('share_backend_name')
self.backend_pools = self.configuration.instorage_nas_pools
self.ssh_runner = SSHRunner(**{
'host': self.configuration.instorage_nas_ip,
'port': 22,
'login': self.configuration.instorage_nas_login,
'password': self.configuration.instorage_nas_password
self.assistant = InStorageAssistant(self.ssh_runner)
def check_for_setup_error(self):
nodes = self.assistant.get_nodes_info()
if len(nodes) == 0:
msg = _('No valid node, be sure the NAS Port IP is configured')
raise exception.ShareBackendException(msg=msg)
pools = self.assistant.get_available_pools()
not_exist = set(self.backend_pools).difference(set(pools))
if not_exist:
msg = _('Pool %s not exist on the storage system') % not_exist
raise exception.InvalidParameterValue(msg)
def _update_share_stats(self, **kwargs):
"""Retrieve share stats information."""
stats = {
'share_backend_name': self.backend_name,
'vendor_name': self.VENDOR,
'driver_version': self.VERSION,
'storage_protocol': 'NFS_CIFS',
'snapshot_support': False,
'create_share_from_snapshot_support': False,
'revert_to_snapshot_support': False,
'qos': False,
'total_capacity_gb': 0.0,
'free_capacity_gb': 0.0,
'pools': []
pools = self.assistant.get_pools_attr(self.backend_pools)
total_capacity_gb = 0
free_capacity_gb = 0
for pool in pools.values():
total_capacity_gb += pool['total_capacity_gb']
free_capacity_gb += pool['free_capacity_gb']
stats['total_capacity_gb'] = total_capacity_gb
stats['free_capacity_gb'] = free_capacity_gb
LOG.debug('share status %s', stats)
super(InStorageShareDriver, self)._update_share_stats(stats)
except Exception:
msg = _('Unexpected error while trying to get the '
'usage stats from array.')
def generate_share_name(share):
# Generate a name with id of the share as base, and do follows:
# 1. Remove the '-' in the id string.
# 2. Transform all alpha to lower case.
# 3. If the first char of the id is a num,
# transform it to an Upper case alpha start from 'A',
# such as '0' -> 'A', '1' -> 'B'.
# e.g.
# generate_share_name({
# 'id': '46CF5E85-D618-4023-8727-6A1EA9292954',
# ...
# })
# returns 'E6cf5e85d618402387276a1ea9292954'
name = share['id'].replace('-', '').lower()
if name[0] in '0123456789':
name = chr(ord('A') + ord(name[0]) - ord('0')) + name[1:]
return name
def get_network_allocations_number(self):
"""Get the number of network interfaces to be created."""
return 0
def create_share(self, context, share, share_server=None):
"""Create a new share instance."""
share_name = self.generate_share_name(share)
share_size = share['size']
share_proto = share['share_proto']
pool_name = share_utils.extract_host(share['host'], level='pool')
return self.assistant.get_export_locations(share_name, share_proto)
def delete_share(self, context, share, share_server=None):
"""Delete the given share instance."""
share_name = self.generate_share_name(share)
share_proto = share['share_proto']
self.assistant.delete_share(share_name, share_proto)
def extend_share(self, share, new_size, share_server=None):
"""Extend the share instance's size to new size."""
share_name = self.generate_share_name(share)
self.assistant.extend_share(share_name, new_size)
def ensure_share(self, context, share, share_server=None):
"""Ensure that the share instance is exported."""
share_name = self.generate_share_name(share)
share_proto = share['share_proto']
return self.assistant.get_export_locations(share_name, share_proto)
def update_access(self, context, share, access_rules, add_rules,
delete_rules, share_server=None):
"""Update the share instance's access rule."""
share_name = self.generate_share_name(share)
share_proto = share['share_proto']
@coordination.synchronized('inspur-instorage-access-' + share_name)
def _update_access(name, proto, rules, add_rules, delete_rules):
name, proto, rules, add_rules, delete_rules
share_name, share_proto, access_rules, add_rules, delete_rules
class InStorageAssistant(object):
def __init__(self, ssh_runner):
self.ssh = InStorageSSH(ssh_runner)
def handle_keyerror(cmd, out):
msg = (_('Could not find key in output of command %(cmd)s: %(out)s.')
% {'out': out, 'cmd': cmd})
raise exception.ShareBackendException(msg=msg)
def size_to_gb(self, size):
new_size = 0
if 'P' in size:
new_size = int(float(size.rstrip('PB')) * units.Mi)
elif 'T' in size:
new_size = int(float(size.rstrip('TB')) * units.Ki)
elif 'G' in size:
new_size = int(float(size.rstrip('GB')) * 1)
elif 'M' in size:
mb_size = float(size.rstrip('MB'))
new_size = int((mb_size + units.Ki - 1) / units.Ki)
return new_size
def get_available_pools(self):
nas_pools = self.ssh.lsnaspool()
return [pool['pool_name'] for pool in nas_pools]
def get_pools_attr(self, backend_pools):
pools = {}
fs_attr = self.ssh.lsfs()
nas_pools = self.ssh.lsnaspool()
for pool_attr in nas_pools:
pool_name = pool_attr['pool_name']
if pool_name not in backend_pools:
total_used_capacity = 0
total_allocated_capacity = 0
for fs in fs_attr:
if fs['pool_name'] != pool_name:
allocated = self.size_to_gb(fs['total_capacity'])
used = self.size_to_gb(fs['used_capacity'])
total_allocated_capacity += allocated
total_used_capacity += used
available = self.size_to_gb(pool_attr['available_capacity'])
pool = {
'pool_name': pool_name,
'total_capacity_gb': total_allocated_capacity + available,
'free_capacity_gb': available,
'allocated_capacity_gb': total_allocated_capacity,
'reserved_percentage': 0,
'qos': False,
'dedupe': False,
'compression': False,
'thin_provisioning': False,
'max_over_subscription_ratio': 0
pools[pool_name] = pool
return pools
def get_nodes_info(self):
"""Return a dictionary containing information of system's nodes."""
nodes = {}
resp = self.ssh.lsnasportip()
for port in resp:
# Port is invalid if it has no IP configured.
if port['ip'] == '':
node_name = port['node_name']
if node_name not in nodes:
nodes[node_name] = {}
node = nodes[node_name]
node[port['id']] = port
except KeyError:
self.handle_keyerror('lsnasportip', port)
return nodes
def get_fsname_by_name(name):
return ('%(fsname)s' % {'fsname': name})[0:32]
def get_dirname_by_name(name):
return ('%(dirname)s' % {'dirname': name})[0:32]
def get_dirpath_by_name(self, name):
fsname = self.get_fsname_by_name(name)
dirname = self.get_dirname_by_name(name)
return '/fs/%(fsname)s/%(dirname)s' % {
'fsname': fsname, 'dirname': dirname
def create_share(self, name, pool, size, proto):
"""Create a share with given info."""
# use one available node as the primary node
nodes = self.get_nodes_info()
if len(nodes) == 0:
msg = _('No valid node, be sure the NAS Port IP is configured')
raise exception.ShareBackendException(msg=msg)
node_name = [key for key in nodes.keys()][0]
# first create the file system on which share will be created
fsname = self.get_fsname_by_name(name)
self.ssh.addfs(fsname, pool, size, node_name)
# then create the directory used for the share
dirpath = self.get_dirpath_by_name(name)
# For CIFS, we need to create a CIFS share.
# For NAS, the share is automatically added when the first
# 'access spec' is added on it.
if proto == 'CIFS':
self.ssh.addcifs(name, dirpath)
def check_share_exist(self, name):
"""Check whether the specified share exist on backend."""
fsname = self.get_fsname_by_name(name)
for fs in self.ssh.lsfs():
if fs['fs_name'] == fsname:
return True
return False
def delete_share(self, name, proto):
"""Delete the given share."""
if not self.check_share_exist(name):
LOG.warning('Share %s does not exist on the backend.', name)
# For CIFS, we have to delete the share first.
# For NAS, when the last client access spec is removed from
# it, the share is automatically deleted.
if proto == 'CIFS':
# then delete the directory
dirpath = self.get_dirpath_by_name(name)
# at last delete the file system
fsname = self.get_fsname_by_name(name)
def extend_share(self, name, new_size):
"""Extend a given share to a new size.
:param name: the name of the share.
:param new_size: the new size the share should be.
# first get the original capacity
old_size = None
fsname = self.get_fsname_by_name(name)
for fs in self.ssh.lsfs():
if fs['fs_name'] == fsname:
old_size = self.size_to_gb(fs['total_capacity'])
if old_size is None:
msg = _('share %s is not available') % name
raise exception.ShareBackendException(msg=msg)
LOG.debug('Extend fs %s from %dGB to %dGB', fsname, old_size, new_size)
self.ssh.expandfs(fsname, new_size - old_size)
def get_export_locations(self, name, share_proto):
"""Get the export locations of a given share.
:param name: the name of the share.
:param share_proto: the protocol of the share.
:return: a list of export locations.
if share_proto == 'NFS':
dirpath = self.get_dirpath_by_name(name)
pattern = '%(ip)s:' + dirpath
elif share_proto == 'CIFS':
pattern = '\\\\%(ip)s\\' + name
msg = _('share protocol %s is not supported') % share_proto
raise exception.ShareBackendException(msg=msg)
# we need get the node so that we know which port ip we can use
node_name = None
fsname = self.get_fsname_by_name(name)
for node in self.ssh.lsnode():
for fs in self.ssh.lsfs(node['name']):
if fs['fs_name'] == fsname:
node_name = node['name']
if node_name:
if node_name is None:
msg = _('share %s is not available') % name
raise exception.ShareBackendException(msg=msg)
locations = []
ports = self.ssh.lsnasportip()
for port in ports:
if port['node_name'] == node_name and port['ip'] != '':
location = pattern % {'ip': port['ip']}
'path': location,
'is_admin_only': False,
'metadata': {}
return locations
def classify_nfs_client_spec(self, client_spec, dirpath):
nfslist = self.ssh.lsnfslist(dirpath)
if len(nfslist):
nfsinfo = self.ssh.lsnfsinfo(dirpath)
spec_set = set([
self.NFS_CLIENT_SPEC_PATTERN % i for i in nfsinfo
spec_set = set()
client_spec_set = set(client_spec)
del_spec = spec_set.difference(client_spec_set)
add_spec = client_spec_set.difference(spec_set)
return list(add_spec), list(del_spec)
def access_rule_to_client_spec(self, access_rule):
if access_rule['access_type'] != 'ip':
msg = _('only ip access type is supported when using NFS protocol')
raise exception.ShareBackendException(msg=msg)
network = ipaddress.ip_network(six.text_type(access_rule['access_to']))
if network.version != 4:
msg = _('only IPV4 is accepted when using NFS protocol')
raise exception.ShareBackendException(msg=msg)
client_spec = self.NFS_CLIENT_SPEC_PATTERN % {
'ip': six.text_type(network.network_address),
'mask': six.text_type(network.netmask),
'rights': access_rule['access_level'],
'all_squash': 'all_squash',
'root_squash': 'root_squash'
return client_spec
def update_nfs_access(self, share_name, access_rules, add_rules,
"""Update a NFS share's access rule."""
dirpath = self.get_dirpath_by_name(share_name)
if add_rules or delete_rules:
add_spec = [
self.access_rule_to_client_spec(r) for r in add_rules
del_spec = [
self.access_rule_to_client_spec(r) for r in delete_rules
_, can_del_spec = self.classify_nfs_client_spec(
[], dirpath
to_del_set = set(del_spec)
can_del_set = set(can_del_spec)
will_del_set = to_del_set.intersection(can_del_set)
del_spec = list(will_del_set)
access_spec = [
self.access_rule_to_client_spec(r) for r in access_rules
add_spec, del_spec = self.classify_nfs_client_spec(
access_spec, dirpath
for spec in del_spec:
self.ssh.rmnfsclient(dirpath, spec)
for spec in add_spec:
self.ssh.addnfsclient(dirpath, spec)
def classify_cifs_rights(self, access_rights, share_name):
cifsinfo = self.ssh.lscifsinfo(share_name)
rights_set = set([
self.CIFS_CLIENT_RIGHT_PATTERN % i for i in cifsinfo
access_rights_set = set(access_rights)
del_rights = rights_set.difference(access_rights_set)
add_rights = access_rights_set.difference(rights_set)
return list(add_rights), list(del_rights)
def access_rule_to_rights(self, access_rule):
if access_rule['access_type'] != 'user':
msg = _('only user access type is supported'
' when using CIFS protocol')
raise exception.ShareBackendException(msg=msg)
'type': 'LU',
'name': access_rule['access_to'],
'rights': access_rule['access_level']
return rights
def update_cifs_access(self, share_name, access_rules, add_rules,
"""Update a CIFS share's access rule."""
if add_rules or delete_rules:
add_rights = [
self.access_rule_to_rights(r) for r in add_rules
del_rights = [
self.access_rule_to_rights(r) for r in delete_rules
access_rights = [
self.access_rule_to_rights(r) for r in access_rules
add_rights, del_rights = self.classify_cifs_rights(
access_rights, share_name
for rights in del_rights:
self.ssh.rmcifsuser(share_name, rights)
for rights in add_rights:
self.ssh.addcifsuser(share_name, rights)
def check_access_type(access_type, *rules):
rule_chain = itertools.chain(*rules)
if all([r['access_type'] == access_type for r in rule_chain]):
return True
return False
def update_access(self, share_name, share_proto,
access_rules, add_rules, delete_rules):
if share_proto == 'CIFS':
if self.check_access_type('user', access_rules,
add_rules, delete_rules):
self.update_cifs_access(share_name, access_rules,
add_rules, delete_rules)
msg = _("Only %s access type allowed.") % "user"
raise exception.InvalidShareAccess(reason=msg)
elif share_proto == 'NFS':
if self.check_access_type('ip', access_rules,
add_rules, delete_rules):
self.update_nfs_access(share_name, access_rules,
add_rules, delete_rules)
msg = _("Only %s access type allowed.") % "ip"
raise exception.InvalidShareAccess(reason=msg)
msg = _('share protocol %s is not supported') % share_proto
raise exception.ShareBackendException(msg=msg)