def check_for_setup_error(self):
"""Returns an error if prerequisites aren't met."""
if not self.configuration.san_password:
raise exception.InvalidInput(reason=translate('Specify san_password'))
# The san_ip must always be set, because we use it for the target
if not self.configuration.san_ip:
raise exception.InvalidInput(reason=translate("san_ip must be set"))
def __call__(self, req):
"""Generate a WSGI response based on the exception passed to ctor."""
# Replace the body with fault details.
locale = req.best_match_language()
code = self.wrapped_exc.status_int
fault_name = self._fault_names.get(code, "computeFault")
explanation = self.wrapped_exc.explanation
fault_data = {
fault_name: {
'code': code,
'message': i18n.translate(explanation, locale)}}
if code == 413:
retry = self.wrapped_exc.headers.get('Retry-After', None)
if retry:
fault_data[fault_name]['retryAfter'] = retry
# 'code' is an attribute on the fault tag itself
metadata = {'attributes': {fault_name: 'code'}}
xml_serializer = XMLDictSerializer(metadata, XML_NS_V2)
content_type = req.best_match_content_type()
serializer = {
'application/xml': xml_serializer,
'application/json': JSONDictSerializer(),
}[content_type]
self.wrapped_exc.body = serializer.serialize(fault_data)
self.wrapped_exc.content_type = content_type
_set_request_id_header(req, self.wrapped_exc.headers)
return self.wrapped_exc
def __call__(self, req):
"""Generate a WSGI response based on the exception passed to ctor."""
# Replace the body with fault details.
locale = req.best_match_language()
code = self.wrapped_exc.status_int
fault_name = self._fault_names.get(code, "computeFault")
explanation = self.wrapped_exc.explanation
fault_data = {
fault_name: {
'code': code,
'message': i18n.translate(explanation, locale)}}
if code == 413:
retry = self.wrapped_exc.headers.get('Retry-After', None)
if retry:
fault_data[fault_name]['retryAfter'] = retry
if (not req.api_version_request.is_null() and not
_is_legacy_endpoint(req)):
self.wrapped_exc.headers[API_VERSION_REQUEST_HEADER] = (
VOLUME_SERVICE + ' ' + req.api_version_request.get_string())
self.wrapped_exc.headers['Vary'] = API_VERSION_REQUEST_HEADER
content_type = req.best_match_content_type()
serializer = {
'application/json': JSONDictSerializer(),
}[content_type]
body = serializer.serialize(fault_data)
if isinstance(body, six.text_type):
body = body.encode('utf-8')
self.wrapped_exc.body = body
self.wrapped_exc.content_type = content_type
_set_request_id_header(req, self.wrapped_exc.headers)
return self.wrapped_exc
def _get_pool(self):
if not self.pool:
pools = self.system.pools.find(id=int(self.configuration.infinidat_pool_id))
if not pools:
raise exception.InvalidInput(translate("pool {0} not found".format(int(self.configuration.infinidat_pool_id))))
self.pool = pools[0]
return self.pool
def create_cloned_volume(self, tgt_cinder_volume, src_cinder_volume):
if tgt_cinder_volume.size < src_cinder_volume.size:
msg = "cannot shrink clone. original size={}, target size={}".format(src_cinder_volume.size, tgt_cinder_volume.size)
raise exception.InvalidInput(reason=translate(msg))
src_infinidat_volume = self._find_volume(src_cinder_volume)
# We first create a snapshot and then a clone from that snapshot.
snapshot = src_infinidat_volume.create_snapshot(name=self._create_snapshot_name(src_cinder_volume) + "-internal")
self._set_obj_metadata(snapshot, {
"cinder_id": "",
"internal": "true"
})
# We now create a clone from the snapshot
tgt_infinidat_volume = snapshot.create_child(name=self._create_volume_name(tgt_cinder_volume))
tgt_infinidat_volume.disable_write_protection()
tgt_infinidat_volume.update_size(tgt_cinder_volume.size * GiB)
if hasattr(tgt_cinder_volume, "consistencygroup") and tgt_cinder_volume.consistencygroup:
cinder_cg = tgt_cinder_volume.consistencygroup
self._add_volume_to_cg(tgt_infinidat_volume, cinder_cg)
else:
cinder_cg = None
self._set_volume_or_snapshot_metadata(
tgt_infinidat_volume,
tgt_cinder_volume,
delete_parent=True,
cinder_cg=cinder_cg)
def __call__(self, req):
"""Generate a WSGI response based on the exception passed to ctor."""
# Replace the body with fault details.
locale = req.best_match_language()
code = self.wrapped_exc.status_int
fault_name = self._fault_names.get(code, "computeFault")
explanation = self.wrapped_exc.explanation
fault_data = {
fault_name: {
'code': code,
'message': i18n.translate(explanation, locale)
}
}
if code == 413:
retry = self.wrapped_exc.headers.get('Retry-After', None)
if retry:
fault_data[fault_name]['retryAfter'] = retry
# 'code' is an attribute on the fault tag itself
metadata = {'attributes': {fault_name: 'code'}}
xml_serializer = XMLDictSerializer(metadata, XML_NS_V2)
content_type = req.best_match_content_type()
serializer = {
'application/xml': xml_serializer,
'application/json': JSONDictSerializer(),
}[content_type]
self.wrapped_exc.body = serializer.serialize(fault_data)
self.wrapped_exc.content_type = content_type
_set_request_id_header(req, self.wrapped_exc.headers)
return self.wrapped_exc
def extend_volume(self, cinder_volume, new_size):
LOG.info("InfiniboxVolumeDriver.extend_volume")
infinidat_volume = self._find_volume(cinder_volume)
new_size_in_bytes = new_size * GiB
if infinidat_volume.get_size() != new_size_in_bytes:
if infinidat_volume.get_size() > new_size_in_bytes:
msg = "cannot shrink volume: new size must be greater or equal to current size. original size={}, new size={}"
raise exception.InvalidInput(reason=translate(msg.format(infinidat_volume.get_size(), new_size_in_bytes)))
infinidat_volume.update_size(new_size_in_bytes)
def _handle_connection(self, protocol_methods, cinder_volume, connector, *args, **kwargs):
preferred_fc = self.configuration.infinidat_prefer_fc
fc, iscsi = connector.get('wwpns'), connector.get('initiator')
if not fc and not iscsi:
raise exception.Invalid(translate(("no wwpns or iscsi initiator in connector {0}".format(connector))))
elif fc and (not iscsi or preferred_fc):
return protocol_methods['fc'](cinder_volume, connector, *args, **kwargs)
else:
return protocol_methods['iscsi'](cinder_volume, connector, *args, **kwargs)
def do_setup(self, context):
from infinisdk.core.exceptions import ObjectNotFound
from infinidat_openstack.config import is_masked, unmask
for key in ('infinidat_provision_type', 'infinidat_pool_id', 'san_login', 'san_password'):
if not self.configuration.safe_get(key):
raise exception.InvalidInput(reason=translate("{0} must be set".format(key)))
provision_type = self.configuration.infinidat_provision_type
if provision_type.upper() not in ('THICK', 'THIN'):
raise exception.InvalidInput(reason=translate("infinidat_provision_type must be THICK or THIN"))
from infinisdk import InfiniBox
self.system = InfiniBox(self.configuration.san_ip,
auth=(self.configuration.san_login,
unmask(self.configuration.san_password) if \
is_masked(self.configuration.san_password) else \
self.configuration.san_password))
self.system.login()
try:
self._get_pool() # we want to search for the pool here so we fail if we can't find it.
except (ObjectNotFound, exception.InvalidInput):
if not self.configuration.infinidat_allow_pool_not_found:
raise
LOG.info("InfiniBox pool not found, but infinidat_allow_pool_not_found is set")
def create_volume_from_snapshot(self, cinder_volume, cinder_snapshot):
infinidat_snapshot = self._find_snapshot(cinder_snapshot)
if cinder_volume.size * GiB < infinidat_snapshot.get_size():
msg = "cannot shrink snapshot. original size={}, target size={}".format(infinidat_snapshot.get_size(), cinder_volume.size * GiB)
raise exception.InvalidInput(reason=translate(msg))
infinidat_volume = infinidat_snapshot.create_child(name=self._create_volume_name(cinder_volume))
infinidat_volume.disable_write_protection()
infinidat_volume.update_size(cinder_volume.size * GiB)
if hasattr(cinder_volume, 'consistencygroup') and cinder_volume.consistencygroup:
cinder_cg = cinder_volume.consistencygroup
self._add_volume_to_cg(infinidat_volume, cinder_cg)
else:
cinder_cg = None
self._set_volume_or_snapshot_metadata(
infinidat_volume,
cinder_volume,
cinder_cg=cinder_cg)
def delete_volume(self, cinder_volume):
from infinisdk.core.exceptions import ObjectNotFound
try:
infinidat_volume = self._find_volume(cinder_volume)
except ObjectNotFound:
LOG.info("delete_volume: volume {0!r} not found in InfiniBox, returning None".format(cinder_volume))
return
metadata = infinidat_volume.get_all_metadata()
if infinidat_volume.has_children():
raise exception.VolumeIsBusy(volume_name=translate(infinidat_volume.get_name()))
delete_parent = metadata.get("delete_parent", "false").lower() == "true"
object_to_delete = infinidat_volume.get_parent() if delete_parent else infinidat_volume
if self.configuration.infinidat_purge_volume_on_deletion:
self._purge_infinidat_volume(object_to_delete)
else:
object_to_delete.delete()
def __call__(self, req):
"""Generate a WSGI response based on the exception passed to ctor."""
# Replace the body with fault details.
locale = req.best_match_language()
code = self.wrapped_exc.status_int
fault_name = self._fault_names.get(code, "computeFault")
explanation = self.wrapped_exc.explanation
fault_data = {
fault_name: {
'code': code,
'message': i18n.translate(explanation, locale)}}
if code == 413:
retry = self.wrapped_exc.headers.get('Retry-After', None)
if retry:
fault_data[fault_name]['retryAfter'] = retry
# 'code' is an attribute on the fault tag itself
metadata = {'attributes': {fault_name: 'code'}}
xml_serializer = XMLDictSerializer(metadata, XML_NS_V2)
content_type = req.best_match_content_type()
serializer = {
'application/xml': xml_serializer,
'application/json': JSONDictSerializer(),
}[content_type]
if content_type == 'application/xml':
global XML_WARNING
if not XML_WARNING:
msg = _('XML support has been deprecated and will be removed '
'in the N release.')
versionutils.report_deprecated_feature(LOG, msg)
XML_WARNING = True
body = serializer.serialize(fault_data)
if isinstance(body, six.text_type):
body = body.encode('utf-8')
self.wrapped_exc.body = body
self.wrapped_exc.content_type = content_type
_set_request_id_header(req, self.wrapped_exc.headers)
return self.wrapped_exc
def translate(msg):
locale = request.best_match_language()
return i18n.translate(msg, locale)
def _assert_connector(self, connector):
if ((u'wwpns' not in connector or not connector[u'wwpns']) and
(u'initiator' not in connector or not connector[u'initiator'])):
LOG.warn("no WWPN or iSCSI initiator was provided in connector: {0!r}".format(connector))
raise exception.Invalid(translate('No WWPN or iSCSI initiator was received'))
def delete_snapshot(self, cinder_snapshot):
infinidat_snapshot = self._find_snapshot(cinder_snapshot)
if infinidat_snapshot.has_children():
raise exception.SnapshotIsBusy(snapshot_name=translate(infinidat_snapshot.get_name()))
infinidat_snapshot.delete()
def translate(msg):
locale = request.best_match_language()
return i18n.translate(msg, locale)
def create_snapshot(self, cinder_snapshot):
infinidat_volume = self._find_volume(cinder_snapshot.volume)
infinidat_snapshot = infinidat_volume.create_snapshot(name=translate(self._create_snapshot_name(cinder_snapshot)))
self._set_volume_or_snapshot_metadata(infinidat_snapshot, cinder_snapshot)
