def test_generate_publish_volume_response(self):
config_a = {
"controller": {
"publish_context_lun_parameter": "lun",
"publish_context_connectivity_parameter": "connectivity_type",
"publish_context_array_iqn": "array_iqn",
"publish_context_fc_initiators": "fc_wwns"
}
}
res = utils.generate_csi_publish_volume_response(
0, "iscsi", config_a, ["1"])
self.assertEqual(res.publish_context["lun"], '0')
self.assertEqual(res.publish_context["connectivity_type"], "iscsi")
self.assertEqual(res.publish_context["array_iqn"], '1')
config_b = {
"controller": {
"publish_context_lun_parameter": "lun",
"publish_context_connectivity_parameter": "connectivity_type",
"publish_context_array_iqn": "array_iqn",
"publish_context_fc_initiators": "fc_wwns"
}
}
res = utils.generate_csi_publish_volume_response(
1, "fc", config_b, ["wwn1", "wwn2"])
self.assertEqual(res.publish_context["lun"], '1')
self.assertEqual(res.publish_context["connectivity_type"], "fc")
self.assertEqual(res.publish_context["fc_wwns"], "wwn1,wwn2")
def test_generate_publish_volume_response_success(self):
res = utils.generate_csi_publish_volume_response(0, "iscsi", self.config,
{"iqn": ["1.1.1.1", "2.2.2.2"],
"iqn2": ["3.3.3.3", "::1"]})
self.assertEqual(res.publish_context["lun"], '0')
self.assertEqual(res.publish_context["connectivity_type"], "iscsi")
self.assertEqual(res.publish_context["array_iqn"], "iqn,iqn2")
self.assertEqual(res.publish_context["iqn"], "1.1.1.1,2.2.2.2")
self.assertEqual(res.publish_context["iqn2"], "3.3.3.3,::1")
res = utils.generate_csi_publish_volume_response(1, "fc", self.config,
["wwn1", "wwn2"])
self.assertEqual(res.publish_context["lun"], '1')
self.assertEqual(res.publish_context["connectivity_type"], "fc")
self.assertEqual(res.publish_context["fc_wwns"], "wwn1,wwn2")
def _check_publish_volume_response_parameters(self, lun, connectivity_type,
array_initiators):
publish_volume_response = utils.generate_csi_publish_volume_response(
lun, connectivity_type, self.config, array_initiators)
self.assertEqual(publish_volume_response.publish_context["lun"], lun)
self.assertEqual(
publish_volume_response.publish_context["connectivity_type"],
connectivity_type)
if connectivity_type == NVME_OVER_FC_CONNECTIVITY_TYPE:
self.assertIsNone(
publish_volume_response.publish_context.get("fc_wwns"))
self.assertIsNone(
publish_volume_response.publish_context.get("array_iqn"))
elif connectivity_type == FC_CONNECTIVITY_TYPE:
self.assertEqual(
publish_volume_response.publish_context["fc_wwns"],
",".join(array_initiators))
self.assertIsNone(
publish_volume_response.publish_context.get("array_iqn"))
elif connectivity_type == ISCSI_CONNECTIVITY_TYPE:
self.assertEqual(
publish_volume_response.publish_context["array_iqn"],
",".join(array_initiators.keys()))
for iqn, ips in array_initiators.items():
self.assertEqual(publish_volume_response.publish_context[iqn],
",".join(ips))
self.assertIsNone(
publish_volume_response.publish_context.get("fc_wwns"))
def ControllerPublishVolume(self, request, context):
set_current_thread_name(request.volume_id)
logger.info("ControllerPublishVolume")
try:
utils.validate_publish_volume_request(request)
array_type, vol_id = utils.get_volume_id_info(request.volume_id)
node_id_info = NodeIdInfo(request.node_id)
node_name = node_id_info.node_name
initiators = node_id_info.initiators
logger.debug("node name for this publish operation is : {0}".format(node_name))
user, password, array_addresses = utils.get_array_connection_info_from_secret(request.secrets)
lun, connectivity_type, array_initiators = map_volume(user, password, array_addresses, array_type, vol_id, initiators)
logger.info("finished ControllerPublishVolume")
res = utils.generate_csi_publish_volume_response(lun,
connectivity_type,
self.cfg,
array_initiators)
return res
except controller_errors.VolumeMappedToMultipleHostsError as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
return csi_pb2.ControllerPublishVolumeResponse()
except controller_errors.PermissionDeniedError as ex:
context.set_code(grpc.StatusCode.PERMISSION_DENIED)
context.set_details(ex)
return csi_pb2.ControllerPublishVolumeResponse()
except (controller_errors.LunAlreadyInUseError, controller_errors.NoAvailableLunError) as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.RESOURCE_EXHAUSTED)
return csi_pb2.ControllerPublishVolumeResponse()
except (controller_errors.HostNotFoundError, controller_errors.VolumeNotFoundError, controller_errors.BadNodeIdError) as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.NOT_FOUND)
return csi_pb2.ControllerPublishVolumeResponse()
except ValidationException as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
return csi_pb2.ControllerPublishVolumeResponse()
except Exception as ex:
logger.debug("an internal exception occurred")
logger.exception(ex)
context.set_code(grpc.StatusCode.INTERNAL)
context.set_details('an internal exception occurred : {}'.format(ex))
return csi_pb2.ControllerPublishVolumeResponse()
def ControllerPublishVolume(self, request, context):
set_current_thread_name(request.volume_id)
logger.info("ControllerPublishVolume")
utils.validate_publish_volume_request(request)
try:
volume_id_info = utils.get_volume_id_info(request.volume_id)
system_id = volume_id_info.system_id
array_type = volume_id_info.array_type
volume_id = volume_id_info.object_id
node_id_info = NodeIdInfo(request.node_id)
node_name = node_id_info.node_name
initiators = node_id_info.initiators
logger.debug(
"node name for this publish operation is : {0}".format(
node_name))
array_connection_info = utils.get_array_connection_info_from_secrets(
request.secrets, system_id=system_id)
with get_agent(array_connection_info,
array_type).get_mediator() as array_mediator:
lun, connectivity_type, array_initiators = array_mediator.map_volume_by_initiators(
volume_id, initiators)
logger.info("finished ControllerPublishVolume")
res = utils.generate_csi_publish_volume_response(
lun, connectivity_type, self.cfg, array_initiators)
return res
except array_errors.VolumeMappedToMultipleHostsError as ex:
return handle_exception(ex, context,
grpc.StatusCode.FAILED_PRECONDITION,
csi_pb2.ControllerPublishVolumeResponse)
except (array_errors.LunAlreadyInUseError,
array_errors.NoAvailableLunError) as ex:
return handle_exception(ex, context,
grpc.StatusCode.RESOURCE_EXHAUSTED,
csi_pb2.ControllerPublishVolumeResponse)
except (array_errors.NoIscsiTargetsFoundError, ObjectIdError) as ex:
return handle_exception(ex, context, grpc.StatusCode.NOT_FOUND,
csi_pb2.ControllerPublishVolumeResponse)
except array_errors.UnsupportedConnectivityTypeError as ex:
return handle_exception(ex, context,
grpc.StatusCode.INVALID_ARGUMENT,
csi_pb2.ControllerPublishVolumeResponse)
def ControllerPublishVolume(self, request, context):
set_current_thread_name(request.volume_id)
logger.info("ControllerPublishVolume")
try:
utils.validate_publish_volume_request(request)
volume_id_info = utils.get_volume_id_info(request.volume_id)
system_id = volume_id_info.system_id
array_type = volume_id_info.array_type
volume_id = volume_id_info.object_id
node_id_info = NodeIdInfo(request.node_id)
node_name = node_id_info.node_name
initiators = node_id_info.initiators
logger.debug(
"node name for this publish operation is : {0}".format(
node_name))
array_connection_info = utils.get_array_connection_info_from_secrets(
request.secrets, system_id=system_id)
with get_agent(array_connection_info,
array_type).get_mediator() as array_mediator:
lun, connectivity_type, array_initiators = array_mediator.map_volume_by_initiators(
volume_id, initiators)
logger.info("finished ControllerPublishVolume")
res = utils.generate_csi_publish_volume_response(
lun, connectivity_type, self.cfg, array_initiators)
return res
except array_errors.VolumeMappedToMultipleHostsError as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.FAILED_PRECONDITION)
return csi_pb2.ControllerPublishVolumeResponse()
except array_errors.PermissionDeniedError as ex:
context.set_code(grpc.StatusCode.PERMISSION_DENIED)
context.set_details(ex.message)
return csi_pb2.ControllerPublishVolumeResponse()
except (array_errors.LunAlreadyInUseError,
array_errors.NoAvailableLunError) as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.RESOURCE_EXHAUSTED)
return csi_pb2.ControllerPublishVolumeResponse()
except (array_errors.HostNotFoundError,
array_errors.ObjectNotFoundError,
array_errors.NoIscsiTargetsFoundError, ObjectIdError) as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.NOT_FOUND)
return csi_pb2.ControllerPublishVolumeResponse()
except (ValidationException, array_errors.IllegalObjectID,
array_errors.UnsupportedConnectivityTypeError) as ex:
logger.exception(ex)
context.set_details(ex.message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
return csi_pb2.ControllerPublishVolumeResponse()
except Exception as ex:
logger.debug("an internal exception occurred")
logger.exception(ex)
context.set_code(grpc.StatusCode.INTERNAL)
context.set_details(
'an internal exception occurred : {}'.format(ex))
return csi_pb2.ControllerPublishVolumeResponse()
