def provision_and_wait_pv(client, core_api, storage_class, pvc): # NOQA
"""
Provision a new Longhorn Volume via Storage Class and wait for the Volume
and its associated resources to be created.
This method also waits for the Kubernetes Status to be properly set on the
Volume.
:param client: An instance of the Longhorn client.
:param core_api: An instance of the Kubernetes CoreV1API client.
:param storage_class: A dict representing a Storage Class spec.
:param pvc: A dict representing a Persistent Volume Claim spec.
:return: The Persistent Volume that was provisioned.
"""
create_storage_class(storage_class)
pvc['spec']['storageClassName'] = storage_class['metadata']['name']
pvc_name = pvc['metadata']['name']
create_pvc(pvc)
pv = wait_and_get_pv_for_pvc(core_api, pvc_name)
volume_name = pv.spec.csi.volume_handle # NOQA
ks = {
'pvName': pv.metadata.name,
'pvStatus': 'Bound',
'namespace': 'default',
'pvcName': pvc_name,
'lastPVCRefAt': '',
'lastPodRefAt': '',
}
wait_volume_kubernetes_status(client, volume_name, ks)
return pv
def test_csi_offline_expansion(client, core_api, storage_class, pvc, pod_manifest): # NOQA
"""
Test CSI feature: offline expansion
1. Create a new `storage_class` with `allowVolumeExpansion` set
2. Create PVC and Pod with dynamic provisioned volume from the StorageClass
3. Generate `test_data` and write to the pod
4. Delete the pod
5. Update pvc.spec.resources to expand the volume
6. Verify the volume expansion done using Longhorn API
7. Create a new pod and validate the volume content
"""
create_storage_class(storage_class)
pod_name = 'csi-offline-expand-volume-test'
pvc_name = pod_name + "-pvc"
pvc['metadata']['name'] = pvc_name
pvc['spec']['storageClassName'] = storage_class['metadata']['name']
create_pvc(pvc)
pod_manifest['metadata']['name'] = pod_name
pod_manifest['spec']['volumes'] = [{
'name':
pod_manifest['spec']['containers'][0]['volumeMounts'][0]['name'],
'persistentVolumeClaim': {'claimName': pvc_name},
}]
create_and_wait_pod(core_api, pod_manifest)
test_data = generate_random_data(VOLUME_RWTEST_SIZE)
write_pod_volume_data(core_api, pod_name, test_data)
delete_and_wait_pod(core_api, pod_name)
pv = wait_and_get_pv_for_pvc(core_api, pvc_name)
assert pv.status.phase == "Bound"
volume_name = pv.spec.csi.volume_handle
wait_for_volume_detached(client, volume_name)
pvc['spec']['resources'] = {
'requests': {
'storage': size_to_string(EXPANDED_VOLUME_SIZE*Gi)
}
}
expand_and_wait_for_pvc(core_api, pvc)
wait_for_volume_expansion(client, volume_name)
volume = client.by_id_volume(volume_name)
assert volume.state == "detached"
assert volume.size == str(EXPANDED_VOLUME_SIZE*Gi)
pod_manifest['metadata']['name'] = pod_name
pod_manifest['spec']['volumes'] = [{
'name':
pod_manifest['spec']['containers'][0]['volumeMounts'][0]['name'],
'persistentVolumeClaim': {'claimName': pvc_name},
}]
create_and_wait_pod(core_api, pod_manifest)
resp = read_volume_data(core_api, pod_name)
assert resp == test_data
volume = client.by_id_volume(volume_name)
engine = get_volume_engine(volume)
assert volume.size == str(EXPANDED_VOLUME_SIZE*Gi)
assert volume.size == engine.size
def test_csi_expansion_with_replica_failure(client, core_api, storage_class, pvc, pod_manifest): # NOQA
"""
Test expansion success but with one replica expansion failure
1. Create a new `storage_class` with `allowVolumeExpansion` set
2. Create PVC and Pod with dynamic provisioned volume from the StorageClass
3. Create an empty directory with expansion snapshot tmp meta file path
for one replica so that the replica expansion will fail
4. Generate `test_data` and write to the pod
5. Delete the pod and wait for volume detachment
6. Update pvc.spec.resources to expand the volume
7. Check expansion result using Longhorn API. There will be expansion error
caused by the failed replica but overall the expansion should succeed.
8. Create a new pod and
check if the volume will rebuild the failed replica
9. Validate the volume content, then check if data writing looks fine
"""
create_storage_class(storage_class)
pod_name = 'csi-expansion-with-replica-failure-test'
pvc_name = pod_name + "-pvc"
pvc['metadata']['name'] = pvc_name
pvc['spec']['storageClassName'] = storage_class['metadata']['name']
create_pvc(pvc)
pod_manifest['metadata']['name'] = pod_name
pod_manifest['spec']['volumes'] = [{
'name':
pod_manifest['spec']['containers'][0]['volumeMounts'][0]['name'],
'persistentVolumeClaim': {'claimName': pvc_name},
}]
create_and_wait_pod(core_api, pod_manifest)
expand_size = str(EXPANDED_VOLUME_SIZE*Gi)
pv = wait_and_get_pv_for_pvc(core_api, pvc_name)
assert pv.status.phase == "Bound"
volume_name = pv.spec.csi.volume_handle
volume = client.by_id_volume(volume_name)
failed_replica = volume.replicas[0]
fail_replica_expansion(client, core_api,
volume_name, expand_size, [failed_replica])
test_data = generate_random_data(VOLUME_RWTEST_SIZE)
write_pod_volume_data(core_api, pod_name, test_data)
delete_and_wait_pod(core_api, pod_name)
wait_for_volume_detached(client, volume_name)
# There will be replica expansion error info
# but the expansion should succeed.
pvc['spec']['resources'] = {
'requests': {
'storage': size_to_string(EXPANDED_VOLUME_SIZE*Gi)
}
}
expand_and_wait_for_pvc(core_api, pvc)
wait_for_expansion_failure(client, volume_name)
wait_for_volume_expansion(client, volume_name)
volume = client.by_id_volume(volume_name)
assert volume.state == "detached"
assert volume.size == expand_size
for r in volume.replicas:
if r.name == failed_replica.name:
assert r.failedAt != ""
else:
assert r.failedAt == ""
# Check if the replica will be rebuilded
# and if the volume still works fine.
create_and_wait_pod(core_api, pod_manifest)
volume = wait_for_volume_healthy(client, volume_name)
for r in volume.replicas:
if r.name == failed_replica.name:
assert r.mode == ""
else:
assert r.mode == "RW"
resp = read_volume_data(core_api, pod_name)
assert resp == test_data
test_data = generate_random_data(VOLUME_RWTEST_SIZE)
write_pod_volume_data(core_api, pod_name, test_data)
resp = read_volume_data(core_api, pod_name)
assert resp == test_data
def test_csi_block_volume(client, core_api, storage_class, pvc, pod_manifest): # NOQA
"""
Test CSI feature: raw block volume
1. Create a PVC with `volumeMode = Block`
2. Create a pod using the PVC to dynamic provision a volume
3. Verify the pod creation
4. Generate `test_data` and write to the block volume directly in the pod
5. Read the data back for validation
6. Delete the pod and create `pod2` to use the same volume
7. Validate the data in `pod2` is consistent with `test_data`
"""
pod_name = 'csi-block-volume-test'
pvc_name = pod_name + "-pvc"
device_path = "/dev/longhorn/longhorn-test-blk"
storage_class['reclaimPolicy'] = 'Retain'
pvc['metadata']['name'] = pvc_name
pvc['spec']['volumeMode'] = 'Block'
pvc['spec']['storageClassName'] = storage_class['metadata']['name']
pvc['spec']['resources'] = {
'requests': {
'storage': size_to_string(1 * Gi)
}
}
pod_manifest['metadata']['name'] = pod_name
pod_manifest['spec']['volumes'] = [{
'name': 'longhorn-blk',
'persistentVolumeClaim': {
'claimName': pvc_name,
},
}]
pod_manifest['spec']['containers'][0]['volumeMounts'] = []
pod_manifest['spec']['containers'][0]['volumeDevices'] = [
{'name': 'longhorn-blk', 'devicePath': device_path}
]
create_storage_class(storage_class)
create_pvc(pvc)
pv_name = wait_and_get_pv_for_pvc(core_api, pvc_name).metadata.name
create_and_wait_pod(core_api, pod_manifest)
test_data = generate_random_data(VOLUME_RWTEST_SIZE)
test_offset = random.randint(0, VOLUME_RWTEST_SIZE)
write_pod_block_volume_data(
core_api, pod_name, test_data, test_offset, device_path)
returned_data = read_pod_block_volume_data(
core_api, pod_name, len(test_data), test_offset, device_path
)
assert test_data == returned_data
md5_sum = get_pod_data_md5sum(
core_api, pod_name, device_path)
delete_and_wait_pod(core_api, pod_name)
common.wait_for_volume_detached(client, pv_name)
pod_name_2 = 'csi-block-volume-test-reuse'
pod_manifest['metadata']['name'] = pod_name_2
create_and_wait_pod(core_api, pod_manifest)
returned_data = read_pod_block_volume_data(
core_api, pod_name_2, len(test_data), test_offset, device_path
)
assert test_data == returned_data
md5_sum_2 = get_pod_data_md5sum(
core_api, pod_name_2, device_path)
assert md5_sum == md5_sum_2
delete_and_wait_pod(core_api, pod_name_2)
delete_and_wait_pvc(core_api, pvc_name)
delete_and_wait_pv(core_api, pv_name)
