1506 lines
61 KiB
Python
1506 lines
61 KiB
Python
# Copyright (c) 2014 ProphetStor, Inc.
|
|
# 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.
|
|
"""
|
|
Implementation of the class of ProphetStor DPL storage adapter of Federator.
|
|
# v2.0.1 Consistency group support
|
|
# v2.0.2 Pool aware scheduler
|
|
# v2.0.3 Consistency group modification support
|
|
# v2.0.4 Port ProphetStor driver to use new driver model
|
|
# v2.0.5 Move from httplib to requests
|
|
"""
|
|
|
|
import base64
|
|
import errno
|
|
import json
|
|
import random
|
|
import time
|
|
|
|
from oslo_log import log as logging
|
|
from oslo_service import loopingcall
|
|
from oslo_utils import units
|
|
import requests
|
|
import six
|
|
from six.moves import http_client
|
|
|
|
from cinder.common import constants
|
|
from cinder import exception
|
|
from cinder.i18n import _
|
|
from cinder import objects
|
|
from cinder.objects import fields
|
|
from cinder.volume import driver
|
|
from cinder.volume.drivers.prophetstor import options
|
|
from cinder.volume.drivers.san import san
|
|
from cinder.volume import volume_utils
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
CONNECTION_RETRY = 10
|
|
MAXSNAPSHOTS = 1024
|
|
DISCOVER_SERVER_TYPE = 'dpl'
|
|
DPL_BLOCKSTOR = '/dpl_blockstor'
|
|
DPL_SYSTEM = '/dpl_system'
|
|
|
|
DPL_VER_V1 = 'v1'
|
|
DPL_OBJ_POOL = 'dpl_pool'
|
|
DPL_OBJ_DISK = 'dpl_disk'
|
|
DPL_OBJ_VOLUME = 'dpl_volume'
|
|
DPL_OBJ_VOLUMEGROUP = 'dpl_volgroup'
|
|
DPL_OBJ_SNAPSHOT = 'cdmi_snapshots'
|
|
DPL_OBJ_EXPORT = 'dpl_export'
|
|
|
|
DPL_OBJ_REPLICATION = 'cdmi_replication'
|
|
DPL_OBJ_TARGET = 'dpl_target'
|
|
DPL_OBJ_SYSTEM = 'dpl_system'
|
|
DPL_OBJ_SNS = 'sns_table'
|
|
|
|
|
|
class DPLCommand(object):
|
|
"""DPL command interface."""
|
|
|
|
def __init__(self, ip, port, username, password, cert_verify=False,
|
|
cert_path=None):
|
|
self.ip = ip
|
|
self.port = port
|
|
self.username = username
|
|
self.password = password
|
|
self.cert_verify = cert_verify
|
|
self.cert_path = cert_path
|
|
|
|
def send_cmd(self, method, url, params, expected_status):
|
|
"""Send command to DPL."""
|
|
retcode = 0
|
|
data = {}
|
|
header = {'Content-Type': 'application/cdmi-container',
|
|
'Accept': 'application/cdmi-container',
|
|
'x-cdmi-specification-version': '1.0.2'}
|
|
# base64 encode the username and password
|
|
auth = base64.encodebytes('%s:%s'
|
|
% (self.username,
|
|
self.password)).replace('\n', '')
|
|
header['Authorization'] = 'Basic %s' % auth
|
|
|
|
if not params:
|
|
payload = None
|
|
else:
|
|
try:
|
|
payload = json.dumps(params, ensure_ascii=False)
|
|
payload.encode('utf-8')
|
|
except Exception as e:
|
|
LOG.error('JSON encode params %(param)s error:'
|
|
' %(status)s.', {'param': params, 'status': e})
|
|
retcode = errno.EINVAL
|
|
|
|
retry = CONNECTION_RETRY
|
|
func = getattr(requests, method.lower())
|
|
|
|
cert_path = False
|
|
if self.cert_verify:
|
|
cert_path = self.cert_path
|
|
else:
|
|
cert_path = False
|
|
|
|
while (retry):
|
|
try:
|
|
r = func(
|
|
url="https://%s:%s%s" % (self.ip, self.port, url),
|
|
data=payload, headers=header, verify=cert_path)
|
|
|
|
if r.status_code == http_client.SERVICE_UNAVAILABLE:
|
|
LOG.error("The flexvisor service is unavailable.")
|
|
continue
|
|
else:
|
|
break
|
|
except Exception as e:
|
|
msg = (_("failed to %(method)s due to %(error)s")
|
|
% {"method": method, "error": six.text_type(e)})
|
|
LOG.error(msg)
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
if (r.status_code in expected_status and
|
|
r.status_code == http_client.NOT_FOUND):
|
|
retcode = errno.ENODATA
|
|
elif r.status_code not in expected_status:
|
|
LOG.error('%(method)s %(url)s unexpected response status: '
|
|
'%(response)s (expects: %(expects)s).',
|
|
{'method': method,
|
|
'url': url,
|
|
'response': http_client.responses[r.status_code],
|
|
'expects': expected_status})
|
|
if r.status_code == http_client.UNAUTHORIZED:
|
|
raise exception.NotAuthorized
|
|
else:
|
|
retcode = errno.EIO
|
|
elif r.status_code is http_client.NOT_FOUND:
|
|
retcode = errno.ENODATA
|
|
elif r.status_code is http_client.ACCEPTED:
|
|
retcode = errno.EAGAIN
|
|
try:
|
|
data = r.json()
|
|
except (TypeError, ValueError) as e:
|
|
LOG.error('Call to json.loads() raised an exception: %s.',
|
|
e)
|
|
retcode = errno.ENOEXEC
|
|
except Exception as e:
|
|
LOG.error('Read response raised an exception: %s.',
|
|
e)
|
|
retcode = errno.ENOEXEC
|
|
elif (r.status_code in [http_client.OK, http_client.CREATED] and
|
|
http_client.NO_CONTENT not in expected_status):
|
|
try:
|
|
data = r.json()
|
|
except (TypeError, ValueError) as e:
|
|
LOG.error('Call to json.loads() raised an exception: %s.',
|
|
e)
|
|
retcode = errno.ENOEXEC
|
|
except Exception as e:
|
|
LOG.error('Read response raised an exception: %s.',
|
|
e)
|
|
retcode = errno.ENOEXEC
|
|
|
|
return retcode, data
|
|
|
|
|
|
class DPLVolume(object):
|
|
|
|
def __init__(self, dplServer, dplPort, dplUser, dplPassword,
|
|
cert_verify=False, cert_path=None):
|
|
self.objCmd = DPLCommand(
|
|
dplServer, dplPort, dplUser, dplPassword, cert_verify=cert_verify,
|
|
cert_path=cert_path)
|
|
|
|
def _execute(self, method, url, params, expected_status):
|
|
if self.objCmd:
|
|
return self.objCmd.send_cmd(method, url, params, expected_status)
|
|
else:
|
|
return -1, None
|
|
|
|
def _gen_snapshot_url(self, vdevid, snapshotid):
|
|
snapshot_url = '/%s/%s/%s' % (vdevid, DPL_OBJ_SNAPSHOT, snapshotid)
|
|
return snapshot_url
|
|
|
|
def get_server_info(self):
|
|
method = 'GET'
|
|
url = ('/%s/%s/' % (DPL_VER_V1, DPL_OBJ_SYSTEM))
|
|
return self._execute(method, url, None,
|
|
[http_client.OK, http_client.ACCEPTED])
|
|
|
|
def create_vdev(self, volumeID, volumeName, volumeDesc, poolID, volumeSize,
|
|
fthinprovision=True, maximum_snapshot=MAXSNAPSHOTS,
|
|
snapshot_quota=None):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, volumeID)
|
|
|
|
if volumeName is None or volumeName == '':
|
|
metadata['display_name'] = volumeID
|
|
else:
|
|
metadata['display_name'] = volumeName
|
|
metadata['display_description'] = volumeDesc
|
|
metadata['pool_uuid'] = poolID
|
|
metadata['total_capacity'] = volumeSize
|
|
metadata['maximum_snapshot'] = maximum_snapshot
|
|
if snapshot_quota is not None:
|
|
metadata['snapshot_quota'] = int(snapshot_quota)
|
|
metadata['properties'] = dict(thin_provision=fthinprovision)
|
|
params['metadata'] = metadata
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def extend_vdev(self, volumeID, volumeName, volumeDesc, volumeSize,
|
|
maximum_snapshot=MAXSNAPSHOTS, snapshot_quota=None):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, volumeID)
|
|
|
|
if volumeName is None or volumeName == '':
|
|
metadata['display_name'] = volumeID
|
|
else:
|
|
metadata['display_name'] = volumeName
|
|
metadata['display_description'] = volumeDesc
|
|
metadata['total_capacity'] = int(volumeSize)
|
|
metadata['maximum_snapshot'] = maximum_snapshot
|
|
if snapshot_quota is not None:
|
|
metadata['snapshot_quota'] = snapshot_quota
|
|
params['metadata'] = metadata
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def delete_vdev(self, volumeID, force=True):
|
|
method = 'DELETE'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, volumeID)
|
|
|
|
metadata['force'] = force
|
|
params['metadata'] = metadata
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NOT_FOUND, http_client.NO_CONTENT])
|
|
|
|
def create_vdev_from_snapshot(self, vdevID, vdevDisplayName, vdevDesc,
|
|
snapshotID, poolID, fthinprovision=True,
|
|
maximum_snapshot=MAXSNAPSHOTS,
|
|
snapshot_quota=None):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevID)
|
|
metadata['snapshot_operation'] = 'copy'
|
|
if vdevDisplayName is None or vdevDisplayName == "":
|
|
metadata['display_name'] = vdevID
|
|
else:
|
|
metadata['display_name'] = vdevDisplayName
|
|
metadata['display_description'] = vdevDesc
|
|
metadata['pool_uuid'] = poolID
|
|
metadata['properties'] = {}
|
|
metadata['maximum_snapshot'] = maximum_snapshot
|
|
if snapshot_quota:
|
|
metadata['snapshot_quota'] = snapshot_quota
|
|
metadata['properties'] = dict(thin_provision=fthinprovision)
|
|
|
|
params['metadata'] = metadata
|
|
params['copy'] = self._gen_snapshot_url(vdevID, snapshotID)
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def spawn_vdev_from_snapshot(self, new_vol_id, src_vol_id,
|
|
vol_display_name, description, snap_id):
|
|
method = 'PUT'
|
|
params = {}
|
|
metadata = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, new_vol_id)
|
|
|
|
metadata['snapshot_operation'] = 'spawn'
|
|
if vol_display_name is None or vol_display_name == '':
|
|
metadata['display_name'] = new_vol_id
|
|
else:
|
|
metadata['display_name'] = vol_display_name
|
|
metadata['display_description'] = description
|
|
params['metadata'] = metadata
|
|
params['copy'] = self._gen_snapshot_url(src_vol_id, snap_id)
|
|
|
|
return self._execute(method, url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def get_pools(self):
|
|
method = 'GET'
|
|
url = '/%s/%s/' % (DPL_VER_V1, DPL_OBJ_POOL)
|
|
return self._execute(method, url, None, [http_client.OK])
|
|
|
|
def get_pool(self, poolid):
|
|
method = 'GET'
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_POOL, poolid)
|
|
return self._execute(method, url, None,
|
|
[http_client.OK, http_client.ACCEPTED])
|
|
|
|
def clone_vdev(self, SourceVolumeID, NewVolumeID, poolID, volumeName,
|
|
volumeDesc, volumeSize, fthinprovision=True,
|
|
maximum_snapshot=MAXSNAPSHOTS, snapshot_quota=None):
|
|
method = 'PUT'
|
|
params = {}
|
|
metadata = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, NewVolumeID)
|
|
metadata["snapshot_operation"] = "clone"
|
|
if volumeName is None or volumeName == '':
|
|
metadata["display_name"] = NewVolumeID
|
|
else:
|
|
metadata["display_name"] = volumeName
|
|
metadata["display_description"] = volumeDesc
|
|
metadata["pool_uuid"] = poolID
|
|
metadata["total_capacity"] = volumeSize
|
|
metadata["maximum_snapshot"] = maximum_snapshot
|
|
if snapshot_quota:
|
|
metadata["snapshot_quota"] = snapshot_quota
|
|
metadata["properties"] = dict(thin_provision=fthinprovision)
|
|
params["metadata"] = metadata
|
|
params["copy"] = SourceVolumeID
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.CREATED,
|
|
http_client.ACCEPTED])
|
|
|
|
def create_vdev_snapshot(self, vdevid, snapshotid, snapshotname='',
|
|
snapshotdes='', isgroup=False):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
if isgroup:
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUMEGROUP, vdevid)
|
|
else:
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
if not snapshotname:
|
|
metadata['display_name'] = snapshotid
|
|
else:
|
|
metadata['display_name'] = snapshotname
|
|
metadata['display_description'] = snapshotdes
|
|
|
|
params['metadata'] = metadata
|
|
params['snapshot'] = snapshotid
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.CREATED,
|
|
http_client.ACCEPTED])
|
|
|
|
def get_vdev(self, vdevid):
|
|
method = 'GET'
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NOT_FOUND])
|
|
|
|
def get_vdev_status(self, vdevid, eventid):
|
|
method = 'GET'
|
|
url = ('/%s/%s/%s/?event_uuid=%s' % (DPL_VER_V1, DPL_OBJ_VOLUME,
|
|
vdevid, eventid))
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK, http_client.NOT_FOUND])
|
|
|
|
def get_pool_status(self, poolid, eventid):
|
|
method = 'GET'
|
|
url = ('/%s/%s/%s/?event_uuid=%s' % (DPL_VER_V1, DPL_OBJ_POOL,
|
|
poolid, eventid))
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK, http_client.NOT_FOUND])
|
|
|
|
def assign_vdev(self, vdevid, iqn, lunname, portal, lunid=0):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
exports = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
metadata['export_operation'] = 'assign'
|
|
exports['Network/iSCSI'] = {}
|
|
target_info = {}
|
|
target_info['logical_unit_number'] = 0
|
|
target_info['logical_unit_name'] = lunname
|
|
permissions = []
|
|
portals = []
|
|
portals.append(portal)
|
|
permissions.append(iqn)
|
|
target_info['permissions'] = permissions
|
|
target_info['portals'] = portals
|
|
exports['Network/iSCSI'] = target_info
|
|
|
|
params['metadata'] = metadata
|
|
params['exports'] = exports
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def assign_vdev_fc(self, vdevid, targetwwpn, initiatorwwpn, lunname,
|
|
lunid=-1):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
exports = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
metadata['export_operation'] = 'assign'
|
|
exports['Network/FC'] = {}
|
|
target_info = {}
|
|
target_info['target_identifier'] = targetwwpn
|
|
target_info['logical_unit_number'] = lunid
|
|
target_info['logical_unit_name'] = lunname
|
|
target_info['permissions'] = initiatorwwpn
|
|
exports['Network/FC'] = target_info
|
|
|
|
params['metadata'] = metadata
|
|
params['exports'] = exports
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def unassign_vdev(self, vdevid, initiatorIqn, targetIqn=''):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
exports = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
metadata['export_operation'] = 'unassign'
|
|
params['metadata'] = metadata
|
|
|
|
exports['Network/iSCSI'] = {}
|
|
exports['Network/iSCSI']['target_identifier'] = targetIqn
|
|
permissions = []
|
|
permissions.append(initiatorIqn)
|
|
exports['Network/iSCSI']['permissions'] = permissions
|
|
|
|
params['exports'] = exports
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NO_CONTENT, http_client.NOT_FOUND])
|
|
|
|
def unassign_vdev_fc(self, vdevid, targetwwpn, initiatorwwpns):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
exports = {}
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
metadata['export_operation'] = 'unassign'
|
|
params['metadata'] = metadata
|
|
|
|
exports['Network/FC'] = {}
|
|
exports['Network/FC']['target_identifier'] = targetwwpn
|
|
permissions = initiatorwwpns
|
|
exports['Network/FC']['permissions'] = permissions
|
|
|
|
params['exports'] = exports
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NO_CONTENT, http_client.NOT_FOUND])
|
|
|
|
def delete_vdev_snapshot(self, objID, snapshotID, isGroup=False):
|
|
method = 'DELETE'
|
|
if isGroup:
|
|
url = ('/%s/%s/%s/%s/%s/' % (DPL_VER_V1,
|
|
DPL_OBJ_VOLUMEGROUP,
|
|
objID,
|
|
DPL_OBJ_SNAPSHOT, snapshotID))
|
|
else:
|
|
url = ('/%s/%s/%s/%s/%s/' % (DPL_VER_V1,
|
|
DPL_OBJ_VOLUME, objID,
|
|
DPL_OBJ_SNAPSHOT, snapshotID))
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NO_CONTENT, http_client.NOT_FOUND])
|
|
|
|
def rollback_vdev(self, vdevid, snapshotid):
|
|
method = 'PUT'
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid)
|
|
|
|
params['copy'] = self._gen_snapshot_url(vdevid, snapshotid)
|
|
|
|
return self._execute(method,
|
|
url, params,
|
|
[http_client.OK, http_client.ACCEPTED])
|
|
|
|
def list_vdev_snapshots(self, vdevid, isGroup=False):
|
|
method = 'GET'
|
|
if isGroup:
|
|
url = ('/%s/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUMEGROUP, vdevid,
|
|
DPL_OBJ_SNAPSHOT))
|
|
else:
|
|
url = ('/%s/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME,
|
|
vdevid, DPL_OBJ_SNAPSHOT))
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK])
|
|
|
|
def query_vdev_snapshot(self, vdevid, snapshotID, isGroup=False):
|
|
method = 'GET'
|
|
if isGroup:
|
|
url = ('/%s/%s/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUMEGROUP,
|
|
vdevid, DPL_OBJ_SNAPSHOT, snapshotID))
|
|
else:
|
|
url = ('/%s/%s/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_VOLUME, vdevid,
|
|
DPL_OBJ_SNAPSHOT, snapshotID))
|
|
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK])
|
|
|
|
def create_target(self, targetID, protocol, displayName, targetAddress,
|
|
description=''):
|
|
method = 'PUT'
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_EXPORT, targetID)
|
|
params['metadata'] = {}
|
|
metadata = params['metadata']
|
|
metadata['type'] = 'target'
|
|
metadata['protocol'] = protocol
|
|
if displayName is None or displayName == '':
|
|
metadata['display_name'] = targetID
|
|
else:
|
|
metadata['display_name'] = displayName
|
|
metadata['display_description'] = description
|
|
metadata['address'] = targetAddress
|
|
return self._execute(method, url, params, [http_client.OK])
|
|
|
|
def get_target(self, targetID):
|
|
method = 'GET'
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_EXPORT, targetID)
|
|
return self._execute(method, url, None, [http_client.OK])
|
|
|
|
def delete_target(self, targetID):
|
|
method = 'DELETE'
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_EXPORT, targetID)
|
|
return self._execute(method,
|
|
url, None,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.NOT_FOUND])
|
|
|
|
def get_target_list(self, type='target'):
|
|
# type = target/initiator
|
|
method = 'GET'
|
|
if type is None:
|
|
url = '/%s/%s/' % (DPL_VER_V1, DPL_OBJ_EXPORT)
|
|
else:
|
|
url = '/%s/%s/?type=%s' % (DPL_VER_V1, DPL_OBJ_EXPORT, type)
|
|
return self._execute(method, url, None, [http_client.OK])
|
|
|
|
def get_sns_table(self, wwpn):
|
|
method = 'PUT'
|
|
params = {}
|
|
url = '/%s/%s/%s/' % (DPL_VER_V1, DPL_OBJ_EXPORT, DPL_OBJ_SNS)
|
|
params['metadata'] = {}
|
|
params['metadata']['protocol'] = 'fc'
|
|
params['metadata']['address'] = str(wwpn)
|
|
return self._execute(method, url, params, [http_client.OK])
|
|
|
|
def create_vg(self, groupID, groupName, groupDesc='', listVolume=None,
|
|
maxSnapshots=MAXSNAPSHOTS, rotationSnapshot=True):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
properties = {}
|
|
url = '/%s/%s/' % (DPL_OBJ_VOLUMEGROUP, groupID)
|
|
if listVolume:
|
|
metadata['volume'] = listVolume
|
|
else:
|
|
metadata['volume'] = []
|
|
metadata['display_name'] = groupName
|
|
metadata['display_description'] = groupDesc
|
|
metadata['maximum_snapshot'] = maxSnapshots
|
|
properties['snapshot_rotation'] = rotationSnapshot
|
|
metadata['properties'] = properties
|
|
params['metadata'] = metadata
|
|
return self._execute(method, url, params,
|
|
[http_client.OK, http_client.ACCEPTED,
|
|
http_client.CREATED])
|
|
|
|
def get_vg(self, groupID):
|
|
method = 'GET'
|
|
url = '/%s/%s/' % (DPL_OBJ_VOLUMEGROUP, groupID)
|
|
return self._execute(method, url, None, [http_client.OK])
|
|
|
|
def delete_vg(self, groupID, force=True):
|
|
method = 'DELETE'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/' % (DPL_OBJ_VOLUMEGROUP, groupID)
|
|
metadata['force'] = force
|
|
params['metadata'] = metadata
|
|
return self._execute(method, url, params,
|
|
[http_client.NO_CONTENT, http_client.NOT_FOUND])
|
|
|
|
def join_vg(self, volumeID, groupID):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/' % (DPL_OBJ_VOLUMEGROUP, groupID)
|
|
metadata['volume_group_operation'] = 'join'
|
|
metadata['volume'] = []
|
|
metadata['volume'].append(volumeID)
|
|
params['metadata'] = metadata
|
|
return self._execute(method, url, params,
|
|
[http_client.OK, http_client.ACCEPTED])
|
|
|
|
def leave_vg(self, volumeID, groupID):
|
|
method = 'PUT'
|
|
metadata = {}
|
|
params = {}
|
|
url = '/%s/%s/' % (DPL_OBJ_VOLUMEGROUP, groupID)
|
|
metadata['volume_group_operation'] = 'leave'
|
|
metadata['volume'] = []
|
|
metadata['volume'].append(volumeID)
|
|
params['metadata'] = metadata
|
|
return self._execute(method, url, params,
|
|
[http_client.OK, http_client.ACCEPTED])
|
|
|
|
|
|
class DPLCOMMONDriver(driver.CloneableImageVD,
|
|
driver.BaseVD):
|
|
"""Class of dpl storage adapter."""
|
|
VERSION = '2.0.5'
|
|
|
|
# ThirdPartySystems wiki page
|
|
CI_WIKI_NAME = "ProphetStor_CI"
|
|
|
|
# TODO(jsbryant) Remove driver in the 'U' release if CI is not fixed.
|
|
SUPPORTED = False
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
cert_path = None
|
|
cert_verify = False
|
|
super(DPLCOMMONDriver, self).__init__(*args, **kwargs)
|
|
if self.configuration:
|
|
self.configuration.append_config_values(options.DPL_OPTS)
|
|
self.configuration.append_config_values(san.san_opts)
|
|
cert_verify = self.configuration.driver_ssl_cert_verify
|
|
cert_path = self.configuration.driver_ssl_cert_path
|
|
|
|
if cert_verify:
|
|
if not cert_path:
|
|
LOG.warning(
|
|
"Flexvisor: cert_verify is enabled but required cert_path"
|
|
" option is missing.")
|
|
cert_path = None
|
|
else:
|
|
cert_path = None
|
|
|
|
self.dpl = DPLVolume(self.configuration.san_ip,
|
|
self.configuration.dpl_port,
|
|
self.configuration.san_login,
|
|
self.configuration.san_password,
|
|
cert_verify=cert_verify,
|
|
cert_path=cert_path)
|
|
self._stats = {}
|
|
|
|
@staticmethod
|
|
def get_driver_options():
|
|
return options.DPL_OPTS
|
|
|
|
def _convert_size_GB(self, size):
|
|
s = round(float(size) / units.Gi, 2)
|
|
if s > 0:
|
|
return s
|
|
else:
|
|
return 0
|
|
|
|
def _conver_uuid2hex(self, strID):
|
|
if strID:
|
|
return strID.replace('-', '')
|
|
else:
|
|
return None
|
|
|
|
def _get_event_uuid(self, output):
|
|
ret = 0
|
|
event_uuid = ""
|
|
|
|
if (type(output) is dict and
|
|
output.get("metadata") and output["metadata"]):
|
|
if (output["metadata"].get("event_uuid") and
|
|
output["metadata"]["event_uuid"]):
|
|
event_uuid = output["metadata"]["event_uuid"]
|
|
else:
|
|
ret = errno.EINVAL
|
|
else:
|
|
ret = errno.EINVAL
|
|
return ret, event_uuid
|
|
|
|
def _wait_event(self, callFun, objuuid, eventid=None):
|
|
nRetry = 30
|
|
fExit = False
|
|
status = {}
|
|
status['state'] = 'error'
|
|
status['output'] = {}
|
|
while nRetry:
|
|
try:
|
|
if eventid:
|
|
ret, output = callFun(
|
|
self._conver_uuid2hex(objuuid),
|
|
self._conver_uuid2hex(eventid))
|
|
else:
|
|
ret, output = callFun(self._conver_uuid2hex(objuuid))
|
|
|
|
if ret == 0:
|
|
if output['completionStatus'] == 'Complete':
|
|
fExit = True
|
|
status['state'] = 'available'
|
|
status['output'] = output
|
|
elif output['completionStatus'] == 'Error':
|
|
fExit = True
|
|
status['state'] = 'error'
|
|
raise loopingcall.LoopingCallDone(retvalue=False)
|
|
else:
|
|
nsleep = random.randint(0, 10)
|
|
value = round(float(nsleep) / 10, 2)
|
|
time.sleep(value)
|
|
elif ret == errno.ENODATA:
|
|
status['state'] = 'deleted'
|
|
fExit = True
|
|
else:
|
|
nRetry -= 1
|
|
time.sleep(3)
|
|
continue
|
|
|
|
except Exception as e:
|
|
LOG.error('Flexvisor failed to get event %(volume)s '
|
|
'(%(status)s).',
|
|
{'volume': eventid, 'status': e})
|
|
raise loopingcall.LoopingCallDone(retvalue=False)
|
|
|
|
if fExit is True:
|
|
break
|
|
return status
|
|
|
|
def _join_volume_group(self, volume, cgId):
|
|
# Join volume group if consistency group id not empty
|
|
msg = ''
|
|
try:
|
|
ret, output = self.dpl.join_vg(
|
|
self._conver_uuid2hex(volume['id']),
|
|
self._conver_uuid2hex(cgId))
|
|
except Exception as e:
|
|
ret = errno.EFAULT
|
|
msg = _('Fexvisor failed to add volume %(id)s '
|
|
'due to %(reason)s.') % {"id": volume['id'],
|
|
"reason": six.text_type(e)}
|
|
if ret:
|
|
if not msg:
|
|
msg = _('Flexvisor failed to add volume %(id)s '
|
|
'to group %(cgid)s.') % {'id': volume['id'],
|
|
'cgid': cgId}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to add volume %(id)s to '
|
|
'group %(cgid)s.',
|
|
{'id': volume['id'], 'cgid': cgId})
|
|
|
|
def _leave_volume_group(self, volume, cgId):
|
|
# Leave volume group if consistency group id not empty
|
|
msg = ''
|
|
try:
|
|
ret, output = self.dpl.leave_vg(
|
|
self._conver_uuid2hex(volume['id']),
|
|
self._conver_uuid2hex(cgId))
|
|
except Exception as e:
|
|
ret = errno.EFAULT
|
|
msg = _('Fexvisor failed to remove volume %(id)s '
|
|
'due to %(reason)s.') % {"id": volume['id'],
|
|
"reason": six.text_type(e)}
|
|
if ret:
|
|
if not msg:
|
|
msg = _('Flexvisor failed to remove volume %(id)s '
|
|
'from group %(cgid)s.') % {'id': volume['id'],
|
|
'cgid': cgId}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to remove volume %(id)s from '
|
|
'group %(cgid)s.',
|
|
{'id': volume['id'], 'cgid': cgId})
|
|
|
|
def _get_snapshotid_of_vgsnapshot(self, vgID, vgsnapshotID, volumeID):
|
|
snapshotID = None
|
|
ret, out = self.dpl.query_vdev_snapshot(vgID, vgsnapshotID, True)
|
|
if ret == 0:
|
|
volumes = out.get('metadata', {}).get('member', {})
|
|
if volumes:
|
|
snapshotID = volumes.get(volumeID, None)
|
|
else:
|
|
msg = _('Flexvisor failed to get snapshot id of volume '
|
|
'%(id)s from group %(vgid)s.') % {'id': volumeID,
|
|
'vgid': vgID}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
if not snapshotID:
|
|
msg = _('Flexvisor could not find volume %(id)s snapshot in'
|
|
' the group %(vgid)s snapshot '
|
|
'%(vgsid)s.') % {'id': volumeID, 'vgid': vgID,
|
|
'vgsid': vgsnapshotID}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
return snapshotID
|
|
|
|
def create_export(self, context, volume, connector):
|
|
pass
|
|
|
|
def ensure_export(self, context, volume):
|
|
pass
|
|
|
|
def remove_export(self, context, volume):
|
|
pass
|
|
|
|
def _create_consistencygroup(self, context, group):
|
|
"""Creates a consistencygroup."""
|
|
LOG.info('Start to create consistency group: %(group_name)s '
|
|
'id: %(id)s',
|
|
{'group_name': group.name, 'id': group.id})
|
|
model_update = {'status': fields.GroupStatus.AVAILABLE}
|
|
try:
|
|
ret, output = self.dpl.create_vg(
|
|
self._conver_uuid2hex(group.id),
|
|
group.name,
|
|
group.description)
|
|
if ret:
|
|
msg = _('Failed to create consistency group '
|
|
'%(id)s:%(ret)s.') % {'id': group.id,
|
|
'ret': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
return model_update
|
|
except Exception as e:
|
|
msg = _('Failed to create consistency group '
|
|
'%(id)s due to %(reason)s.') % {'id': group.id,
|
|
'reason': six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
def _delete_consistencygroup(self, context, group, volumes):
|
|
"""Delete a consistency group."""
|
|
ret = 0
|
|
volumes = self.db.volume_get_all_by_group(
|
|
context, group.id)
|
|
model_update = {}
|
|
model_update['status'] = group.status
|
|
LOG.info('Start to delete consistency group: %(cg_name)s',
|
|
{'cg_name': group.id})
|
|
try:
|
|
self.dpl.delete_vg(self._conver_uuid2hex(group.id))
|
|
except Exception as e:
|
|
msg = _('Failed to delete consistency group %(id)s '
|
|
'due to %(reason)s.') % {'id': group.id,
|
|
'reason': six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
for volume_ref in volumes:
|
|
try:
|
|
self.dpl.delete_vdev(self._conver_uuid2hex(volume_ref['id']))
|
|
volume_ref['status'] = 'deleted'
|
|
except Exception:
|
|
ret = errno.EFAULT
|
|
volume_ref['status'] = 'error_deleting'
|
|
model_update['status'] = (
|
|
fields.GroupStatus.ERROR_DELETING)
|
|
if ret == 0:
|
|
model_update['status'] = fields.GroupStatus.DELETED
|
|
return model_update, volumes
|
|
|
|
def _create_cgsnapshot(self, context, cgsnapshot, snapshots):
|
|
"""Creates a cgsnapshot."""
|
|
snapshots = objects.SnapshotList().get_all_for_group_snapshot(
|
|
context, cgsnapshot.id)
|
|
model_update = {}
|
|
LOG.info('Start to create cgsnapshot for consistency group'
|
|
': %(group_name)s',
|
|
{'group_name': cgsnapshot.group_id})
|
|
try:
|
|
self.dpl.create_vdev_snapshot(
|
|
self._conver_uuid2hex(cgsnapshot.group_id),
|
|
self._conver_uuid2hex(cgsnapshot.id),
|
|
cgsnapshot.name,
|
|
'',
|
|
True)
|
|
for snapshot in snapshots:
|
|
snapshot.status = fields.SnapshotStatus.AVAILABLE
|
|
except Exception as e:
|
|
msg = _('Failed to create cg snapshot %(id)s '
|
|
'due to %(reason)s.') % {'id': cgsnapshot.id,
|
|
'reason': six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
model_update['status'] = 'available'
|
|
|
|
return model_update, snapshots
|
|
|
|
def _delete_cgsnapshot(self, context, cgsnapshot, snapshots):
|
|
"""Deletes a cgsnapshot."""
|
|
snapshots = objects.SnapshotList().get_all_for_group_snapshot(
|
|
context, cgsnapshot.id)
|
|
model_update = {}
|
|
model_update['status'] = cgsnapshot.status
|
|
LOG.info('Delete cgsnapshot %(snap_name)s for consistency group: '
|
|
'%(group_name)s',
|
|
{'snap_name': cgsnapshot.id,
|
|
'group_name': cgsnapshot.group_id})
|
|
try:
|
|
self.dpl.delete_vdev_snapshot(
|
|
self._conver_uuid2hex(cgsnapshot.group_id),
|
|
self._conver_uuid2hex(cgsnapshot.id), True)
|
|
for snapshot in snapshots:
|
|
snapshot.status = fields.SnapshotStatus.DELETED
|
|
except Exception as e:
|
|
msg = _('Failed to delete cgsnapshot %(id)s due to '
|
|
'%(reason)s.') % {'id': cgsnapshot.id,
|
|
'reason': six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
model_update['status'] = 'deleted'
|
|
return model_update, snapshots
|
|
|
|
def update_group(self, context, group, add_volumes=None,
|
|
remove_volumes=None):
|
|
addvollist = []
|
|
removevollist = []
|
|
cgid = group.id
|
|
vid = ''
|
|
model_update = {'status': fields.GroupStatus.AVAILABLE}
|
|
if not volume_utils.is_group_a_cg_snapshot_type(group):
|
|
raise NotImplementedError()
|
|
# Get current group info in backend storage.
|
|
ret, output = self.dpl.get_vg(self._conver_uuid2hex(cgid))
|
|
if ret == 0:
|
|
group_members = output.get('children', [])
|
|
|
|
if add_volumes:
|
|
addvollist = add_volumes
|
|
if remove_volumes:
|
|
removevollist = remove_volumes
|
|
|
|
# Process join volumes.
|
|
try:
|
|
for volume in addvollist:
|
|
vid = volume['id']
|
|
# Verify the volume exists in the group or not.
|
|
if self._conver_uuid2hex(vid) in group_members:
|
|
continue
|
|
self._join_volume_group(volume, cgid)
|
|
except Exception as e:
|
|
msg = _("Fexvisor failed to join the volume %(vol)s in the "
|
|
"group %(group)s due to "
|
|
"%(ret)s.") % {"vol": vid, "group": cgid,
|
|
"ret": six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
# Process leave volumes.
|
|
try:
|
|
for volume in removevollist:
|
|
vid = volume['id']
|
|
if self._conver_uuid2hex(vid) in group_members:
|
|
self._leave_volume_group(volume, cgid)
|
|
except Exception as e:
|
|
msg = _("Fexvisor failed to remove the volume %(vol)s in the "
|
|
"group %(group)s due to "
|
|
"%(ret)s.") % {"vol": vid, "group": cgid,
|
|
"ret": six.text_type(e)}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
return model_update, None, None
|
|
|
|
def create_group(self, context, group):
|
|
if volume_utils.is_group_a_cg_snapshot_type(group):
|
|
return self._create_consistencygroup(context, group)
|
|
raise NotImplementedError()
|
|
|
|
def delete_group(self, context, group, volumes):
|
|
if volume_utils.is_group_a_cg_snapshot_type(group):
|
|
return self._delete_consistencygroup(context, group, volumes)
|
|
raise NotImplementedError()
|
|
|
|
def create_group_snapshot(self, context, group_snapshot, snapshots):
|
|
if volume_utils.is_group_a_cg_snapshot_type(group_snapshot):
|
|
return self._create_cgsnapshot(context, group_snapshot, snapshots)
|
|
raise NotImplementedError()
|
|
|
|
def delete_group_snapshot(self, context, group_snapshot, snapshots):
|
|
if volume_utils.is_group_a_cg_snapshot_type(group_snapshot):
|
|
return self._delete_cgsnapshot(context, group_snapshot, snapshots)
|
|
raise NotImplementedError()
|
|
|
|
def create_group_from_src(self, context, group, volumes,
|
|
group_snapshot=None, snapshots=None,
|
|
source_group=None, source_vols=None):
|
|
err_msg = _("Prophet Storage doesn't support create_group_from_src.")
|
|
LOG.error(err_msg)
|
|
raise exception.VolumeBackendAPIException(data=err_msg)
|
|
|
|
def create_volume(self, volume):
|
|
"""Create a volume."""
|
|
pool = volume_utils.extract_host(volume['host'],
|
|
level='pool')
|
|
if not pool:
|
|
if not self.configuration.dpl_pool:
|
|
msg = _("Pool is not available in the volume host fields.")
|
|
raise exception.InvalidHost(reason=msg)
|
|
else:
|
|
pool = self.configuration.dpl_pool
|
|
|
|
ret, output = self.dpl.create_vdev(
|
|
self._conver_uuid2hex(volume['id']),
|
|
volume.get('display_name', ''),
|
|
volume.get('display_description', ''),
|
|
pool,
|
|
int(volume['size']) * units.Gi,
|
|
self.configuration.san_thin_provision)
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
volume['id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to create volume %(volume)s: '
|
|
'%(status)s.') % {'volume': volume['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to create volume (get event) '
|
|
'%s.') % (volume['id'])
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor create volume failed.:%(volumeid)s:'
|
|
'%(status)s.') % {'volumeid': volume['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to create volume %(id)s.',
|
|
{'id': volume['id']})
|
|
|
|
if volume.group_id:
|
|
group = volume_utils.group_get_by_id(volume.group_id)
|
|
if volume_utils.is_group_a_cg_snapshot_type(group):
|
|
try:
|
|
self._join_volume_group(volume, volume.group_id)
|
|
except Exception:
|
|
# Delete volume if volume failed to join group.
|
|
self.dpl.delete_vdev(self._conver_uuid2hex(volume['id']))
|
|
msg = _('Flexvisor failed to create volume %(id)s in the '
|
|
'group %(vgid)s.') % {
|
|
'id': volume['id'],
|
|
'vgid': volume.group_id}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
def create_volume_from_snapshot(self, volume, snapshot):
|
|
"""Creates a volume from a snapshot."""
|
|
src_volume = None
|
|
vgID = None
|
|
# Detect whether a member of the group.
|
|
snapshotID = snapshot['id']
|
|
# Try to get cgid if volume belong in the group.
|
|
src_volumeID = snapshot['volume_id']
|
|
cgsnapshotID = snapshot.get('group_snapshot_id', None)
|
|
if cgsnapshotID:
|
|
try:
|
|
src_volume = self.db.volume_get(src_volumeID)
|
|
except Exception:
|
|
msg = _("Flexvisor unable to find the source volume "
|
|
"%(id)s info.") % {'id': src_volumeID}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
if src_volume:
|
|
vgID = src_volume.group_id
|
|
|
|
# Get the volume origin snapshot id if the source snapshot is group
|
|
# snapshot.
|
|
if vgID:
|
|
snapshotID = self._get_snapshotid_of_vgsnapshot(
|
|
self._conver_uuid2hex(vgID),
|
|
self._conver_uuid2hex(cgsnapshotID),
|
|
self._conver_uuid2hex(src_volumeID))
|
|
|
|
pool = volume_utils.extract_host(volume['host'],
|
|
level='pool')
|
|
if not pool:
|
|
if not self.configuration.dpl_pool:
|
|
msg = _("Pool is not available in the volume host fields.")
|
|
raise exception.InvalidHost(reason=msg)
|
|
else:
|
|
pool = self.configuration.dpl_pool
|
|
|
|
ret, output = self.dpl.create_vdev_from_snapshot(
|
|
self._conver_uuid2hex(volume['id']),
|
|
volume.get('display_name', ''),
|
|
volume.get('display_description', ''),
|
|
self._conver_uuid2hex(snapshotID),
|
|
pool,
|
|
self.configuration.san_thin_provision)
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
volume['id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to create volume from '
|
|
'snapshot %(id)s:'
|
|
'%(status)s.') % {'id': snapshot['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to create volume from snapshot '
|
|
'(failed to get event) '
|
|
'%(id)s.') % {'id': snapshot['id']}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to create volume from snapshot '
|
|
'%(id)s: %(status)s.') % {'id': snapshot['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to create volume %(id)s '
|
|
'from snapshot.', {'id': volume['id']})
|
|
|
|
if volume['size'] > snapshot['volume_size']:
|
|
self.extend_volume(volume, volume['size'])
|
|
|
|
if volume.group_id:
|
|
group = volume_utils.group_get_by_id(volume.group_id)
|
|
if volume_utils.is_group_a_cg_snapshot_type(group):
|
|
try:
|
|
self._join_volume_group(volume, volume.group_id)
|
|
except Exception:
|
|
# Delete volume if volume failed to join group.
|
|
self.dpl.delete_vdev(self._conver_uuid2hex(volume['id']))
|
|
raise
|
|
|
|
def spawn_volume_from_snapshot(self, volume, snapshot):
|
|
"""Spawn a REFERENCED volume from a snapshot."""
|
|
ret, output = self.dpl.spawn_vdev_from_snapshot(
|
|
self._conver_uuid2hex(volume['id']),
|
|
self._conver_uuid2hex(snapshot['volume_id']),
|
|
volume.get('display_name', ''),
|
|
volume.get('display_description', ''),
|
|
self._conver_uuid2hex(snapshot['id']))
|
|
|
|
if ret == errno.EAGAIN:
|
|
# its an async process
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
volume['id'], event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to spawn volume from snapshot '
|
|
'%(id)s:%(status)s.') % {'id': snapshot['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to spawn volume from snapshot '
|
|
'(failed to get event) '
|
|
'%(id)s.') % {'id': snapshot['id']}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to create volume from snapshot '
|
|
'%(id)s: %(status)s.') % {'id': snapshot['id'],
|
|
'status': ret}
|
|
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to create volume %(id)s '
|
|
'from snapshot.', {'id': volume['id']})
|
|
|
|
def create_cloned_volume(self, volume, src_vref):
|
|
"""Creates a clone of the specified volume."""
|
|
pool = volume_utils.extract_host(volume['host'],
|
|
level='pool')
|
|
if not pool:
|
|
if not self.configuration.dpl_pool:
|
|
msg = _("Pool is not available in the volume host fields.")
|
|
raise exception.InvalidHost(reason=msg)
|
|
else:
|
|
pool = self.configuration.dpl_pool
|
|
|
|
ret, output = self.dpl.clone_vdev(
|
|
self._conver_uuid2hex(src_vref['id']),
|
|
self._conver_uuid2hex(volume['id']),
|
|
pool,
|
|
volume.get('display_name', ''),
|
|
volume.get('display_description', ''),
|
|
int(volume['size']) * units.Gi,
|
|
self.configuration.san_thin_provision)
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
volume['id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to clone volume %(id)s: '
|
|
'%(status)s.') % {'id': src_vref['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to clone volume (failed to'
|
|
' get event) %(id)s.') % {'id': src_vref['id']}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to clone volume %(id)s: '
|
|
'%(status)s.') % {'id': src_vref['id'], 'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to clone volume %(id)s.',
|
|
{'id': volume['id']})
|
|
|
|
if volume.group_id:
|
|
group = volume_utils.group_get_by_id(volume.group_id)
|
|
if volume_utils.is_group_a_cg_snapshot_type(group):
|
|
try:
|
|
self._join_volume_group(volume, volume.group_id)
|
|
except Exception:
|
|
# Delete volume if volume failed to join group.
|
|
self.dpl.delete_vdev(self._conver_uuid2hex(volume['id']))
|
|
msg = _('Flexvisor volume %(id)s failed to join group '
|
|
'%(vgid)s.') % {'id': volume['id'],
|
|
'vgid': volume.group_id}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
def delete_volume(self, volume):
|
|
"""Deletes a volume."""
|
|
ret = 0
|
|
if volume.group_id:
|
|
group = volume_utils.group_get_by_id(volume.group_id)
|
|
if group and volume_utils.is_group_a_cg_snapshot_type(group):
|
|
msg = ''
|
|
try:
|
|
ret, out = self.dpl.leave_vg(
|
|
self._conver_uuid2hex(volume['id']),
|
|
self._conver_uuid2hex(volume.group_id))
|
|
if ret:
|
|
LOG.warning('Flexvisor failed to delete volume '
|
|
'%(id)s from the group %(vgid)s.',
|
|
{'id': volume['id'],
|
|
'vgid': volume.group_id})
|
|
except Exception as e:
|
|
LOG.warning('Flexvisor failed to delete volume %(id)s '
|
|
'from group %(vgid)s due to %(status)s.',
|
|
{'id': volume['id'],
|
|
'vgid': volume.group_id,
|
|
'status': e})
|
|
|
|
if ret:
|
|
ret = 0
|
|
|
|
ret, output = self.dpl.delete_vdev(self._conver_uuid2hex(volume['id']))
|
|
if ret == errno.EAGAIN:
|
|
status = self._wait_event(self.dpl.get_vdev, volume['id'])
|
|
if status['state'] == 'error':
|
|
msg = _('Flexvisor failed deleting volume %(id)s: '
|
|
'%(status)s.') % {'id': volume['id'], 'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret == errno.ENODATA:
|
|
ret = 0
|
|
LOG.info('Flexvisor volume %(id)s does not '
|
|
'exist.', {'id': volume['id']})
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to delete volume %(id)s: '
|
|
'%(status)s.') % {'id': volume['id'], 'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
|
|
def extend_volume(self, volume, new_size):
|
|
ret, output = self.dpl.extend_vdev(self._conver_uuid2hex(volume['id']),
|
|
volume.get('display_name', ''),
|
|
volume.get('display_description',
|
|
''),
|
|
new_size * units.Gi)
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
volume['id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to extend volume '
|
|
'%(id)s:%(status)s.') % {'id': volume,
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to extend volume '
|
|
'(failed to get event) '
|
|
'%(id)s.') % {'id': volume['id']}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to extend volume '
|
|
'%(id)s: %(status)s.') % {'id': volume['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(
|
|
data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to extend volume'
|
|
' %(id)s.', {'id': volume['id']})
|
|
|
|
def create_snapshot(self, snapshot):
|
|
"""Creates a snapshot."""
|
|
ret, output = self.dpl.create_vdev_snapshot(
|
|
self._conver_uuid2hex(snapshot['volume_id']),
|
|
self._conver_uuid2hex(snapshot['id']),
|
|
snapshot.get('display_name', ''),
|
|
snapshot.get('display_description', ''))
|
|
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
snapshot['volume_id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = (_('Flexvisor failed to create snapshot for volume '
|
|
'%(id)s: %(status)s.') %
|
|
{'id': snapshot['volume_id'], 'status': ret})
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
msg = (_('Flexvisor failed to create snapshot for volume '
|
|
'(failed to get event) %(id)s.') %
|
|
{'id': snapshot['volume_id']})
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to create snapshot for volume %(id)s: '
|
|
'%(status)s.') % {'id': snapshot['volume_id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
|
|
def delete_snapshot(self, snapshot):
|
|
"""Deletes a snapshot."""
|
|
ret, output = self.dpl.delete_vdev_snapshot(
|
|
self._conver_uuid2hex(snapshot['volume_id']),
|
|
self._conver_uuid2hex(snapshot['id']))
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_vdev_status,
|
|
snapshot['volume_id'],
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to delete snapshot %(id)s: '
|
|
'%(status)s.') % {'id': snapshot['id'],
|
|
'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
msg = _('Flexvisor failed to delete snapshot (failed to '
|
|
'get event) %(id)s.') % {'id': snapshot['id']}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
elif ret == errno.ENODATA:
|
|
LOG.info('Flexvisor snapshot %(id)s not existed.',
|
|
{'id': snapshot['id']})
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to delete snapshot %(id)s: '
|
|
'%(status)s.') % {'id': snapshot['id'], 'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
LOG.info('Flexvisor succeeded to delete snapshot %(id)s.',
|
|
{'id': snapshot['id']})
|
|
|
|
def _get_pools(self):
|
|
pools = []
|
|
qpools = []
|
|
# Defined access pool by cinder configuration.
|
|
defined_pool = self.configuration.dpl_pool
|
|
if defined_pool:
|
|
qpools.append(defined_pool)
|
|
else:
|
|
try:
|
|
ret, output = self.dpl.get_pools()
|
|
if ret == 0:
|
|
for poolUuid, poolName in output.get('children', []):
|
|
qpools.append(poolUuid)
|
|
else:
|
|
LOG.error("Flexvisor failed to get pool list."
|
|
" (Error: %d)", ret)
|
|
except Exception as e:
|
|
LOG.error("Flexvisor failed to get pool list due to "
|
|
"%s.", e)
|
|
|
|
# Query pool detail information
|
|
for poolid in qpools:
|
|
ret, output = self._get_pool_info(poolid)
|
|
if ret == 0:
|
|
pool = {}
|
|
pool['pool_name'] = output['metadata']['pool_uuid']
|
|
pool['total_capacity_gb'] = (
|
|
self._convert_size_GB(
|
|
int(output['metadata']['total_capacity'])))
|
|
pool['free_capacity_gb'] = (
|
|
self._convert_size_GB(
|
|
int(output['metadata']['available_capacity'])))
|
|
pool['QoS_support'] = False
|
|
pool['reserved_percentage'] = 0
|
|
pools.append(pool)
|
|
else:
|
|
LOG.warning("Failed to query pool %(id)s status "
|
|
"%(ret)d.", {'id': poolid, 'ret': ret})
|
|
continue
|
|
return pools
|
|
|
|
def _update_volume_stats(self, refresh=False):
|
|
"""Return the current state of the volume service.
|
|
|
|
If 'refresh' is True, run the update first.
|
|
"""
|
|
data = {}
|
|
pools = self._get_pools()
|
|
data['volume_backend_name'] = (
|
|
self.configuration.safe_get('volume_backend_name'))
|
|
location_info = '%(driver)s:%(host)s:%(volume)s' % {
|
|
'driver': self.__class__.__name__,
|
|
'host': self.configuration.san_ip,
|
|
'volume': self.configuration.dpl_pool
|
|
}
|
|
try:
|
|
ret, output = self.dpl.get_server_info()
|
|
if ret == 0:
|
|
data['vendor_name'] = output['metadata']['vendor']
|
|
data['driver_version'] = output['metadata']['version']
|
|
data['storage_protocol'] = constants.ISCSI
|
|
data['location_info'] = location_info
|
|
data['consistencygroup_support'] = True
|
|
data['consistent_group_snapshot_enabled'] = True
|
|
data['pools'] = pools
|
|
self._stats = data
|
|
except Exception as e:
|
|
LOG.error('Failed to get server info due to '
|
|
'%(state)s.', {'state': e})
|
|
return self._stats
|
|
|
|
def do_setup(self, context):
|
|
"""Any initialization the volume driver does while starting."""
|
|
self.context = context
|
|
LOG.info('Activate Flexvisor cinder volume driver.')
|
|
|
|
def check_for_setup_error(self):
|
|
"""Check DPL can connect properly."""
|
|
pass
|
|
|
|
def _get_pool_info(self, poolid):
|
|
"""Query pool information."""
|
|
ret, output = self.dpl.get_pool(poolid)
|
|
if ret == errno.EAGAIN:
|
|
ret, event_uuid = self._get_event_uuid(output)
|
|
if ret == 0:
|
|
status = self._wait_event(self.dpl.get_pool_status, poolid,
|
|
event_uuid)
|
|
if status['state'] != 'available':
|
|
msg = _('Flexvisor failed to get pool info %(id)s: '
|
|
'%(status)s.') % {'id': poolid, 'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
ret = 0
|
|
output = status.get('output', {})
|
|
else:
|
|
LOG.error('Flexvisor failed to get pool %(id)s info.',
|
|
{'id': poolid})
|
|
raise exception.VolumeBackendAPIException(
|
|
data="failed to get event")
|
|
elif ret != 0:
|
|
msg = _('Flexvisor failed to get pool info %(id)s: '
|
|
'%(status)s.') % {'id': poolid, 'status': ret}
|
|
raise exception.VolumeBackendAPIException(data=msg)
|
|
else:
|
|
LOG.debug('Flexvisor succeeded to get pool info.')
|
|
return ret, output
|