def get_non_implemented(self, param1=None, param2=None):
# Call to Get Not Implemented Answer API
# @rtype: KSResponse
# @returns: KumoScale response data
#
return entities.ProvisionerResponse(None, None, "Not implemented")
def test_initialize_connection_host_probe_exception(
self, mock_host_probe, mock_publish, mock_get_volumes_by_uuid,
mock_get_targets, mock_get_backend_by_id):
testvol = _stub_volume()
testconn = _stub_connector()
prov_target = TargetEntity('target.nqn', prov_backend1)
prov_portal = PortalEntity('1.2.3.4', 4420, 'TCP')
backend = BackendEntity([prov_portal])
prov_targets_response = entities.ProvisionerResponse([prov_target])
mock_publish.return_value = success_prov_response
mock_host_probe.side_effect = Exception()
mock_get_volumes_by_uuid.return_value = prov_volumes_response
mock_get_targets.return_value = prov_targets_response
mock_get_backend_by_id.return_value = \
entities.ProvisionerResponse([backend])
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.initialize_connection, testvol, testconn)
def result_support(self, result):
if result is not None:
if result.data is not None:
if "Status 401" in str(result.data):
ClassBuilder()
return entities.ProvisionerResponse(
None, None, "Bad credentials")
if "Status 403" in str(result.data):
return entities.ProvisionerResponse(
None, None, "Access is denied")
if str(result.data) == "":
return entities.ProvisionerResponse([], None, "Success")
try:
result_data = json.loads(result.data)
if ('status' in result_data
and result_data['status'] != "Success"):
return entities.ProvisionerResponse(
result_data, None, result_data['status'],
result_data['description'])
return entities.ProvisionerResponse(result_data)
except Exception as e:
return entities.ProvisionerResponse(
None, None,
type(e).__name__, e.message)
return entities.ProvisionerResponse(None, None,
"Provisioner Communication Error",
"Provisioner Communication Error")
def get_hosts(self):
# Call to Get Hosts API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data
#
result_response = self.provisioner_get_request('hosts')
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def get_license(self):
# Call to Get License API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data
#
result_response = self.provisioner_get_request('license')
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity)
return result_response
def get_tenants(self):
# Call to List of Tenants API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data contain List of Volumes
#
result_response = self.provisioner_get_request('tenants')
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def get_targets(self, host_uuid, volume_uuid):
# Call to Get Targets API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data
#
if host_uuid is None and volume_uuid is None:
return entities.ProvisionerResponse(None, None, "ParametersError",
"All parameters missing")
if host_uuid is not None:
request = "?hostId=" + host_uuid
else:
request = "?volId=" + volume_uuid
if host_uuid is not None and volume_uuid is not None:
request += "&volId=" + volume_uuid
result_response = self.provisioner_get_request('targets' + request)
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def get_backend_by_id(self, uuid):
# Call to List of Backends API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data contain List of Backends
#
result_response = self.provisioner_get_request('backends/' + uuid)
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def get_info(self):
# Call to Get Info API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data contain Provisioner information
#
result_response = self.provisioner_get_request('info')
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity)
return result_response
def test_initialize_connection(self, mock_host_probe,
mock_publish,
mock_get_volumes_by_uuid,
mock_get_targets,
mock_get_backend_by_id):
testvol = _stub_volume()
testconn = _stub_connector()
prov_target1 = TargetEntity('target.nqn', prov_backend1)
prov_portal = PortalEntity('1.2.3.4', 4420, 'TCP')
backend = BackendEntity([prov_portal])
prov_targets_response = entities.ProvisionerResponse([prov_target1])
mock_publish.return_value = success_prov_response
mock_host_probe.return_value = success_prov_response
mock_get_volumes_by_uuid.return_value = prov_volumes_response
mock_get_targets.return_value = prov_targets_response
mock_get_backend_by_id.return_value = \
entities.ProvisionerResponse([backend])
result = self.driver.initialize_connection(testvol, testconn)
mock_host_probe.assert_any_call(testconn['nqn'],
testconn['uuid'],
testconn['host'],
'Agent', 'cinder-driver-0.1', 30)
mock_publish.assert_any_call(testconn['uuid'], testvol['id'])
mock_get_volumes_by_uuid.assert_any_call(testvol['id'])
mock_get_targets.assert_any_call(testconn['uuid'], testvol['id'])
mock_get_backend_by_id.assert_any_call('dummy-pid-1')
expected_replica = {'portals': [('1.2.3.4', '4420', 'TCP')],
'target_nqn': 'target.nqn',
'vol_uuid': testvol['id']}
expected_data = {
'vol_uuid': testvol['id'],
'alias': testvol['name'],
'writable': True,
'volume_replicas': [expected_replica]
}
expected_result = {
'driver_volume_type': 'nvmeof',
'data': expected_data
}
self.assertDictEqual(result, expected_result)
def get_volumes(self, tenant_uuid=None):
# Call to List of Volumes API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data contain List of Volumes
#
tenant_id = ""
if tenant_uuid is not None:
tenant_id = tenant_uuid + "/"
result_response = self.provisioner_get_request(tenant_id + 'volumes')
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def test_initialize_connection_no_backend(self, mock_host_probe,
mock_publish,
mock_get_volumes_by_uuid,
mock_get_targets,
mock_get_backend_by_id):
testvol = _stub_volume()
testconn = _stub_connector()
prov_target = TargetEntity('target.nqn', prov_backend1)
prov_targets_response = entities.ProvisionerResponse([prov_target])
mock_publish.return_value = success_prov_response
mock_host_probe.return_value = success_prov_response
mock_get_volumes_by_uuid.return_value = prov_volumes_response
mock_get_targets.return_value = prov_targets_response
mock_get_backend_by_id.return_value = no_entities_prov_response
self.assertRaises(exception.VolumeBackendAPIException,
self.driver.initialize_connection, testvol, testconn)
def get_tasks(self, task_id=None, host_id=None):
# Call to Get Tasks API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data
#
if task_id is not None:
cmd = "tasks?taskId=" + str(task_id)
elif host_id is not None:
cmd = "tasks?hostId=" + str(host_id)
else:
cmd = "tasks"
result_response = self.provisioner_get_request(cmd)
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def get_snapshots_by_alias(self, alias, tenant_uuid=None):
# Call to Get Snapshot Information via alias API
# @rtype: ProvisionerResponse
# @returns: Provisioner response data contain List of Volumes
#
tenant_id = ""
if tenant_uuid is not None:
tenant_id = tenant_uuid + "/"
result_response = self.provisioner_get_request(tenant_id +
'snapshots_by_alias/' +
alias)
if result_response.status == "Success":
result_entity = JsonToClass(result_response.prov_entities, True)
return entities.ProvisionerResponse(result_entity.records)
return result_response
def test_get_volume_stats(self, mock_get_tenants):
tenant = TenantEntity(1000, 400)
mock_get_tenants.return_value = entities.ProvisionerResponse([tenant])
result = self.driver.get_volume_stats(True)
mock_get_tenants.assert_any_call()
self.assertDictEqual(result, self.expected_stats)
from cinder.volume import configuration as conf
from cinder.volume.drivers.kioxia import entities
from cinder.volume.drivers.kioxia import kumoscale as kioxia
from cinder.volume.drivers.kioxia import rest_client
VOL_BACKEND_NAME = 'kioxia_kumoscale_1'
VOL_NAME = 'volume-c2fd04e3-320e-44eb-b-2'
VOL_UUID = 'c20aba21-6ef6-446b-b374-45733b4883ba'
VOL_SIZE = 10
VOL_PROTOCOL = 'NVMeoF'
SNAP_UUID = 'c9ef9d49-0d26-44cb-b609-0b8bd2d3db77'
CONN_UUID = '34206309-3733-4cc6-a7d5-9d4dbbe377da'
CONN_HOST_NAME = 'devstack'
CONN_NQN = 'nqn.2014-08.org.nvmexpress:uuid:' \
'beaae2de-3a97-4be1-a739-6ac4bc5bf138'
success_prov_response = entities.ProvisionerResponse(None, None, "Success",
"Success")
fail_prov_response = entities.ProvisionerResponse(None, None, "Failure",
"Failure")
prov_backend1 = entities.Backend(None, None, None, None, 'dummy-pid-1')
prov_backend2 = entities.Backend(None, None, None, None, 'dummy-pid-2')
prov_location1 = entities.Location(VOL_UUID, prov_backend1)
prov_location2 = entities.Location(VOL_UUID, prov_backend2)
prov_volume = entities.VolumeProv(VOL_UUID, None, None, None,
None, None, None, None, None, None,
None, True, None, [prov_location1,
prov_location2])
prov_volumes_response = entities.ProvisionerResponse([prov_volume])
no_entities_prov_response = entities.ProvisionerResponse([], None, "Success")
class KioxiaVolumeTestCase(test.TestCase):
