def csi_io_test(client, core_api, csi_pv, pvc, pod_make, base_image=""): # NOQA
pv_name = generate_volume_name()
pod_name = 'csi-io-test'
create_and_wait_csi_pod_named_pv(pv_name, pod_name, client, core_api,
csi_pv, pvc, pod_make, base_image, "")
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)
common.wait_for_volume_detached(client, csi_pv['metadata']['name'])
pod_name = 'csi-io-test-2'
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [
create_pvc_spec(pv_name)
]
csi_pv['metadata']['name'] = pv_name
csi_pv['spec']['csi']['volumeHandle'] = pv_name
pvc['metadata']['name'] = pv_name
pvc['spec']['volumeName'] = pv_name
update_storageclass_references(CSI_PV_TEST_STORAGE_NAME, csi_pv, pvc)
create_and_wait_pod(core_api, pod)
resp = read_volume_data(core_api, pod_name)
assert resp == test_data
def csi_io_test(client, core_api, csi_pv, pvc, pod_make, base_image=""): # NOQA
pv_name = generate_volume_name()
pod_name = 'csi-io-test'
create_and_wait_csi_pod_named_pv(pv_name, pod_name, client, core_api,
csi_pv, pvc, pod_make, base_image, "")
test_data = generate_random_data(VOLUME_RWTEST_SIZE)
write_volume_data(core_api, pod_name, test_data)
delete_and_wait_pod(core_api, pod_name)
common.wait_for_volume_detached(client, csi_pv['metadata']['name'])
pod_name = 'csi-io-test-2'
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [
create_pvc_spec(pv_name)
]
csi_pv['metadata']['name'] = pv_name
csi_pv['spec']['csi']['volumeHandle'] = pv_name
pvc['metadata']['name'] = pv_name
pvc['spec']['volumeName'] = pv_name
update_storageclass_references(CSI_PV_TEST_STORAGE_NAME, csi_pv, pvc)
create_and_wait_pod(core_api, pod)
resp = read_volume_data(core_api, pod_name)
assert resp == test_data
def create_and_wait_csi_pod_named_pv(pv_name, pod_name, client, core_api, csi_pv, pvc, pod_make, base_image, from_backup): # NOQA
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [
create_pvc_spec(pv_name)
]
csi_pv['metadata']['name'] = pv_name
csi_pv['spec']['csi']['volumeHandle'] = pv_name
csi_pv['spec']['csi']['volumeAttributes']['fromBackup'] = from_backup
pvc['metadata']['name'] = pv_name
pvc['spec']['volumeName'] = pv_name
update_storageclass_references(CSI_PV_TEST_STORAGE_NAME, csi_pv, pvc)
create_pv_storage(core_api, client, csi_pv, pvc, base_image, from_backup)
create_and_wait_pod(core_api, pod)
def create_and_wait_csi_pod_named_pv(pv_name, pod_name, client, core_api, csi_pv, pvc, pod_make, base_image, from_backup): # NOQA
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [
create_pvc_spec(pv_name)
]
csi_pv['metadata']['name'] = pv_name
csi_pv['spec']['csi']['volumeHandle'] = pv_name
csi_pv['spec']['csi']['volumeAttributes']['fromBackup'] = from_backup
pvc['metadata']['name'] = pv_name
pvc['spec']['volumeName'] = pv_name
update_storageclass_references(CSI_PV_TEST_STORAGE_NAME, csi_pv, pvc)
create_pv_storage(core_api, client, csi_pv, pvc, base_image, from_backup)
create_and_wait_pod(core_api, pod)
def test_csi_minimal_volume_size(
client, core_api, csi_pv, pvc, pod_make): # NOQA
"""
Test CSI Minimal Volume Size
1. Create a PVC requesting size 5MiB. Check the PVC requested size is
5MiB and capacity size get is 10MiB.
2. Remove the PVC.
3. Create a PVC requesting size 10MiB. Check the PVC requested size and
capacity size get are both 10MiB.
4. Create a pod to use this PVC.
5. Write some data to the volume and read it back to compare.
"""
vol_name = generate_volume_name()
create_and_check_volume(client, vol_name, size=str(100*Mi))
low_storage = str(5*Mi)
min_storage = str(10*Mi)
pv_name = vol_name + "-pv"
csi_pv['metadata']['name'] = pv_name
csi_pv['spec']['csi']['volumeHandle'] = vol_name
csi_pv['spec']['capacity']['storage'] = min_storage
core_api.create_persistent_volume(csi_pv)
pvc_name = vol_name + "-pvc"
pvc['metadata']['name'] = pvc_name
pvc['spec']['volumeName'] = pv_name
pvc['spec']['resources']['requests']['storage'] = low_storage
pvc['spec']['storageClassName'] = ''
core_api.create_namespaced_persistent_volume_claim(body=pvc,
namespace='default')
claim = common.wait_for_pvc_phase(core_api, pvc_name, "Bound")
assert claim.spec.resources.requests['storage'] == low_storage
assert claim.status.capacity['storage'] == min_storage
common.delete_and_wait_pvc(core_api, pvc_name)
common.delete_and_wait_pv(core_api, pv_name)
wait_for_volume_detached(client, vol_name)
core_api.create_persistent_volume(csi_pv)
pvc['spec']['resources']['requests']['storage'] = min_storage
core_api.create_namespaced_persistent_volume_claim(body=pvc,
namespace='default')
claim = common.wait_for_pvc_phase(core_api, pvc_name, "Bound")
assert claim.spec.resources.requests['storage'] == min_storage
assert claim.status.capacity['storage'] == min_storage
pod_name = vol_name + '-pod'
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [create_pvc_spec(pvc_name)]
create_and_wait_pod(core_api, pod)
test_data = "longhorn-integration-test"
test_file = "test"
write_pod_volume_data(core_api, pod_name, test_data, test_file)
read_data = read_volume_data(core_api, pod_name, test_file)
assert read_data == test_data
def test_csi_volumesnapshot_restore_existing_backup(
set_random_backupstore, # NOQA
client, # NOQA
core_api, # NOQA
volume_name, # NOQA
csi_pv, # NOQA
pvc, # NOQA
pod_make, # NOQA
volumesnapshotclass, # NOQA
volumesnapshotcontent,
volumesnapshot, # NOQA
volsnapshotclass_delete_policy, # NOQA
backup_is_deleted): # NOQA
"""
Test retention of a backup while deleting the associated `VolumeSnapshot`
via the csi snapshotter
Context:
We want to allow the user to programmatically create/restore/delete
longhorn backups via the csi snapshot mechanism
ref: https://kubernetes.io/docs/concepts/storage/volume-snapshots/
Setup:
1. Make sure your cluster contains the below crds
https://github.com/kubernetes-csi/external-snapshotter
/tree/master/client/config/crd
2. Make sure your cluster contains the snapshot controller
https://github.com/kubernetes-csi/external-snapshotter
/tree/master/deploy/kubernetes/snapshot-controller
Steps:
1. create new snapshotClass with deletionPolicy set to Retain
2. call csi_volumesnapshot_creation_test(snapshotClass=custom)
3. call csi_volumesnapshot_restore_test()
4. call csi_volumesnapshot_deletion_test(deletionPolicy='Retain'):
5. cleanup
"""
csisnapclass = \
volumesnapshotclass(name="snapshotclass",
deletepolicy=volsnapshotclass_delete_policy)
pod_name, pv_name, pvc_name, md5sum = \
prepare_pod_with_data_in_mb(client, core_api,
csi_pv, pvc, pod_make,
volume_name,
data_path="/data/test")
volume = client.by_id_volume(volume_name)
snap = create_snapshot(client, volume_name)
volume.snapshotBackup(name=snap.name)
wait_for_backup_completion(client, volume_name, snap.name)
bv, b = find_backup(client, volume_name, snap.name)
csivolsnap_name = volume_name + "-volumesnapshot"
csivolsnap_namespace = "default"
volsnapcontent = \
volumesnapshotcontent("volsnapcontent",
csisnapclass["metadata"]["name"],
"Delete",
"bs://" + volume_name + "/" + b.name,
csivolsnap_name,
csivolsnap_namespace)
csivolsnap = volumesnapshot(csivolsnap_name, csivolsnap_namespace,
csisnapclass["metadata"]["name"],
"volumeSnapshotContentName",
volsnapcontent["metadata"]["name"])
restore_pvc_name = pvc["metadata"]["name"] + "-restore"
restore_pvc_size = pvc["spec"]["resources"]["requests"]["storage"]
restore_csi_volume_snapshot(core_api, client, csivolsnap, restore_pvc_name,
restore_pvc_size)
restore_pod = pod_make()
restore_pod_name = restore_pod["metadata"]["name"]
restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]
create_and_wait_pod(core_api, restore_pod)
restore_md5sum = \
get_pod_data_md5sum(core_api, restore_pod_name, path="/data/test")
assert restore_md5sum == md5sum
# Delete volumeSnapshot test
delete_volumesnapshot(csivolsnap["metadata"]["name"], "default")
if backup_is_deleted is False:
find_backup(client, volume_name, b["snapshotName"])
else:
wait_for_backup_delete(client, volume_name, b["name"])
def test_csi_volumesnapshot_basic(
set_random_backupstore, # NOQA
volumesnapshotclass, # NOQA
volumesnapshot, # NOQA
client, # NOQA
core_api, # NOQA
volume_name, # NOQA
csi_pv, # NOQA
pvc, # NOQA
pod_make, # NOQA
volsnapshotclass_delete_policy, # NOQA
backup_is_deleted): # NOQA
"""
Test creation / restoration / deletion of a backup via the csi snapshotter
Context:
We want to allow the user to programmatically create/restore/delete
longhorn backups via the csi snapshot mechanism
ref: https://kubernetes.io/docs/concepts/storage/volume-snapshots/
Setup:
1. Make sure your cluster contains the below crds
https://github.com/kubernetes-csi/external-snapshotter
/tree/master/client/config/crd
2. Make sure your cluster contains the snapshot controller
https://github.com/kubernetes-csi/external-snapshotter
/tree/master/deploy/kubernetes/snapshot-controller
Steps:
def csi_volumesnapshot_creation_test(snapshotClass=longhorn|custom):
1. create volume(1)
2. write data to volume(1)
3. create a kubernetes `VolumeSnapshot` object
the `VolumeSnapshot.uuid` will be used to identify a
**longhorn snapshot** and the associated `VolumeSnapshotContent` object
4. check creation of a new longhorn snapshot named `snapshot-uuid`
5. check for `VolumeSnapshotContent` named `snapcontent-uuid`
6. wait for `VolumeSnapshotContent.readyToUse` flag to be set to **true**
7. check for backup existance on the backupstore
# the csi snapshot restore sets the fromBackup field same as
# the StorageClass based restore approach.
def csi_volumesnapshot_restore_test():
8. create a `PersistentVolumeClaim` object where the `dataSource` field
references the `VolumeSnapshot` object by name
9. verify creation of a new volume(2) bound to the pvc created in step(8)
10. verify data of new volume(2) equals data
from backup (ie old data above)
# default longhorn snapshot class is set to Delete
# add a second test with a custom snapshot class with deletionPolicy
# set to Retain you can reuse these methods for that and other tests
def csi_volumesnapshot_deletion_test(deletionPolicy='Delete|Retain'):
11. delete `VolumeSnapshot` object
12. if deletionPolicy == Delete:
13. verify deletion of `VolumeSnapshot` and
`VolumeSnapshotContent` objects
14. verify deletion of backup from backupstore
12. if deletionPolicy == Retain:
13. verify deletion of `VolumeSnapshot`
14. verify retention of `VolumeSnapshotContent`
and backup on backupstore
15. cleanup
"""
csisnapclass = \
volumesnapshotclass(name="snapshotclass",
deletepolicy=volsnapshotclass_delete_policy)
pod_name, pv_name, pvc_name, md5sum = \
prepare_pod_with_data_in_mb(client, core_api,
csi_pv, pvc, pod_make,
volume_name,
data_path="/data/test")
# Create volumeSnapshot test
csivolsnap = volumesnapshot(volume_name + "-volumesnapshot", "default",
csisnapclass["metadata"]["name"],
"persistentVolumeClaimName", pvc_name)
volume = client.by_id_volume(volume_name)
for i in range(RETRY_COUNTS):
snapshots = volume.snapshotList()
if len(snapshots) == 2:
break
time.sleep(RETRY_INTERVAL)
lh_snapshot = None
snapshots = volume.snapshotList()
for snapshot in snapshots:
if snapshot["name"] == "snapshot-" + csivolsnap["metadata"]["uid"]:
lh_snapshot = snapshot
assert lh_snapshot is not None
wait_for_volumesnapshot_ready(csivolsnap["metadata"]["name"],
csivolsnap["metadata"]["namespace"])
bv1, b = find_backup(client, volume_name, lh_snapshot["name"])
assert b["snapshotName"] == lh_snapshot["name"]
restore_pvc_name = pvc["metadata"]["name"] + "-restore"
restore_pvc_size = pvc["spec"]["resources"]["requests"]["storage"]
restore_csi_volume_snapshot(core_api, client, csivolsnap, restore_pvc_name,
restore_pvc_size)
restore_pod = pod_make()
restore_pod_name = restore_pod["metadata"]["name"]
restore_pod['spec']['volumes'] = [create_pvc_spec(restore_pvc_name)]
create_and_wait_pod(core_api, restore_pod)
restore_md5sum = \
get_pod_data_md5sum(core_api, restore_pod_name, path="/data/test")
assert restore_md5sum == md5sum
# Delete volumeSnapshot test
delete_volumesnapshot(csivolsnap["metadata"]["name"], "default")
if backup_is_deleted is False:
find_backup(client, volume_name, b["snapshotName"])
else:
wait_for_backup_delete(client, volume_name, b["name"])
def test_upgrade(upgrade_image_tag, settings_reset, volume_name, pod_make, statefulset, storage_class): # NOQA
"""
Test Longhorn upgrade
Prerequisite:
- Disable Auto Salvage Setting
1. Find the upgrade image tag
2. Create a volume, generate and write data into the volume.
3. Create a Pod using a volume, generate and write data
4. Create a StatefulSet with 2 replicas,
generate and write data to their volumes
5. Keep all volumes attached
6. Upgrade Longhorn system.
7. Check Pod and StatefulSet didn't restart after upgrade
8. Check All volumes data
9. Write data to StatefulSet pods, and Attached volume
10. Check data written to StatefulSet pods, and attached volume.
11. Detach the volume, and Delete Pod, and
StatefulSet to detach theirvolumes
12. Upgrade all volumes engine images.
13. Attach the volume, and recreate Pod, and StatefulSet
14. Check All volumes data
"""
new_ei_name = "longhornio/longhorn-engine:" + upgrade_image_tag
client = get_longhorn_api_client()
core_api = get_core_api_client()
host_id = get_self_host_id()
pod_data_path = "/data/test"
pod_volume_name = generate_volume_name()
auto_salvage_setting = client.by_id_setting(SETTING_AUTO_SALVAGE)
setting = client.update(auto_salvage_setting, value="false")
assert setting.name == SETTING_AUTO_SALVAGE
assert setting.value == "false"
# Create Volume attached to a node.
volume1 = create_and_check_volume(client,
volume_name,
size=SIZE)
volume1.attach(hostId=host_id)
volume1 = wait_for_volume_healthy(client, volume_name)
volume1_data = write_volume_random_data(volume1)
# Create Volume used by Pod
pod_name, pv_name, pvc_name, pod_md5sum = \
prepare_pod_with_data_in_mb(client, core_api,
pod_make, pod_volume_name,
data_path=pod_data_path,
add_liveness_prope=False)
# Create multiple volumes used by StatefulSet
statefulset_name = 'statefulset-upgrade-test'
update_statefulset_manifests(statefulset,
storage_class,
statefulset_name)
create_storage_class(storage_class)
create_and_wait_statefulset(statefulset)
statefulset_pod_info = get_statefulset_pod_info(core_api, statefulset)
for sspod_info in statefulset_pod_info:
sspod_info['data'] = generate_random_data(VOLUME_RWTEST_SIZE)
write_pod_volume_data(core_api,
sspod_info['pod_name'],
sspod_info['data'])
# upgrade Longhorn
assert longhorn_upgrade(upgrade_image_tag)
client = get_longhorn_api_client()
# wait for 1 minute before checking pod restarts
time.sleep(60)
pod = core_api.read_namespaced_pod(name=pod_name,
namespace='default')
assert pod.status.container_statuses[0].restart_count == 0
for sspod_info in statefulset_pod_info:
sspod = core_api.read_namespaced_pod(name=sspod_info['pod_name'],
namespace='default')
assert \
sspod.status.container_statuses[0].restart_count == 0
for sspod_info in statefulset_pod_info:
resp = read_volume_data(core_api, sspod_info['pod_name'])
assert resp == sspod_info['data']
res_pod_md5sum = get_pod_data_md5sum(core_api, pod_name, pod_data_path)
assert res_pod_md5sum == pod_md5sum
check_volume_data(volume1, volume1_data)
for sspod_info in statefulset_pod_info:
sspod_info['data'] = generate_random_data(VOLUME_RWTEST_SIZE)
write_pod_volume_data(core_api,
sspod_info['pod_name'],
sspod_info['data'])
for sspod_info in statefulset_pod_info:
resp = read_volume_data(core_api, sspod_info['pod_name'])
assert resp == sspod_info['data']
volume1 = client.by_id_volume(volume_name)
volume1_data = write_volume_random_data(volume1)
check_volume_data(volume1, volume1_data)
statefulset['spec']['replicas'] = replicas = 0
apps_api = get_apps_api_client()
apps_api.patch_namespaced_stateful_set(
name=statefulset_name,
namespace='default',
body={
'spec': {
'replicas': replicas
}
})
delete_and_wait_pod(core_api, pod_name)
volume = client.by_id_volume(volume_name)
volume.detach()
volumes = client.list_volume()
for v in volumes:
wait_for_volume_detached(client, v.name)
engineimages = client.list_engine_image()
for ei in engineimages:
if ei.image == new_ei_name:
new_ei = ei
volumes = client.list_volume()
for v in volumes:
volume = client.by_id_volume(v.name)
volume.engineUpgrade(image=new_ei.image)
statefulset['spec']['replicas'] = replicas = 2
apps_api = get_apps_api_client()
apps_api.patch_namespaced_stateful_set(
name=statefulset_name,
namespace='default',
body={
'spec': {
'replicas': replicas
}
})
wait_statefulset(statefulset)
pod = pod_make(name=pod_name)
pod['spec']['volumes'] = [create_pvc_spec(pvc_name)]
create_and_wait_pod(core_api, pod)
volume1 = client.by_id_volume(volume_name)
volume1.attach(hostId=host_id)
volume1 = wait_for_volume_healthy(client, volume_name)
for sspod_info in statefulset_pod_info:
resp = read_volume_data(core_api, sspod_info['pod_name'])
assert resp == sspod_info['data']
res_pod_md5sum = get_pod_data_md5sum(core_api, pod_name, pod_data_path)
assert res_pod_md5sum == pod_md5sum
check_volume_data(volume1, volume1_data)
def test_engine_live_upgrade_with_intensive_data_writing(
client, core_api, volume_name, pod_make): # NOQA
"""
Test engine live upgrade with intensive data writing
1. Deploy a compatible new engine image
2. Create a volume(with the old default engine image) with /PV/PVC/Pod
and wait for pod to be deployed.
3. Write data to a tmp file in the pod and get the md5sum
4. Upgrade the volume to the new engine image without waiting.
5. Keep copying data from the tmp file to the volume
during the live upgrade.
6. Wait until the upgrade completed, verify the volume engine image changed
7. Wait for new replica mode update then check the engine status.
8. Verify all engine and replicas' engine image changed
9. Verify the reference count of the new engine image changed
10. Check the existing data.
Then write new data to the upgraded volume and get the md5sum.
11. Delete the pod and wait for the volume detached.
Then check engine and replicas's engine image again.
12. Recreate the pod.
13. Check if the attached volume is state `healthy`
rather than `degraded`.
14. Check the data.
"""
default_img = common.get_default_engine_image(client)
default_img_name = default_img.name
default_img = wait_for_engine_image_ref_count(client, default_img_name, 0)
cli_v = default_img.cliAPIVersion
cli_minv = default_img.cliAPIMinVersion
ctl_v = default_img.controllerAPIVersion
ctl_minv = default_img.controllerAPIMinVersion
data_v = default_img.dataFormatVersion
data_minv = default_img.dataFormatMinVersion
engine_upgrade_image = common.get_upgrade_test_image(
cli_v, cli_minv, ctl_v, ctl_minv, data_v, data_minv)
new_img = client.create_engine_image(image=engine_upgrade_image)
new_img_name = new_img.name
ei_status_value = get_engine_image_status_value(client, new_img_name)
new_img = wait_for_engine_image_state(client, new_img_name,
ei_status_value)
assert new_img.refCount == 0
assert new_img.noRefSince != ""
default_img = common.get_default_engine_image(client)
default_img_name = default_img.name
pod_name = volume_name + "-pod"
pv_name = volume_name + "-pv"
pvc_name = volume_name + "-pvc"
pod = pod_make(name=pod_name)
volume = create_and_check_volume(client,
volume_name,
num_of_replicas=3,
size=str(1 * Gi))
original_engine_image = volume.engineImage
assert original_engine_image != engine_upgrade_image
create_pv_for_volume(client, core_api, volume, pv_name)
create_pvc_for_volume(client, core_api, volume, pvc_name)
pod['spec']['volumes'] = [create_pvc_spec(pvc_name)]
create_and_wait_pod(core_api, pod)
volume = client.by_id_volume(volume_name)
assert volume.engineImage == original_engine_image
assert volume.currentImage == original_engine_image
engine = get_volume_engine(volume)
assert engine.engineImage == original_engine_image
assert engine.currentImage == original_engine_image
for replica in volume.replicas:
assert replica.engineImage == original_engine_image
assert replica.currentImage == original_engine_image
data_path0 = "/tmp/test"
data_path1 = "/data/test1"
write_pod_volume_random_data(core_api, pod_name, data_path0,
RANDOM_DATA_SIZE_LARGE)
original_md5sum1 = get_pod_data_md5sum(core_api, pod_name, data_path0)
volume.engineUpgrade(image=engine_upgrade_image)
# Keep writing data to the volume during the live upgrade
copy_pod_volume_data(core_api, pod_name, data_path0, data_path1)
# Wait for live upgrade complete
wait_for_volume_current_image(client, volume_name, engine_upgrade_image)
volume = wait_for_volume_replicas_mode(client, volume_name, "RW")
engine = get_volume_engine(volume)
assert engine.engineImage == engine_upgrade_image
check_volume_endpoint(volume)
wait_for_engine_image_ref_count(client, default_img_name, 0)
wait_for_engine_image_ref_count(client, new_img_name, 1)
volume_file_md5sum1 = get_pod_data_md5sum(core_api, pod_name, data_path1)
assert volume_file_md5sum1 == original_md5sum1
data_path2 = "/data/test2"
write_pod_volume_random_data(core_api, pod_name, data_path2,
RANDOM_DATA_SIZE_SMALL)
original_md5sum2 = get_pod_data_md5sum(core_api, pod_name, data_path2)
delete_and_wait_pod(core_api, pod_name)
volume = wait_for_volume_detached(client, volume_name)
assert len(volume.replicas) == 3
assert volume.engineImage == engine_upgrade_image
engine = get_volume_engine(volume)
assert engine.engineImage == engine_upgrade_image
for replica in volume.replicas:
assert replica.engineImage == engine_upgrade_image
create_and_wait_pod(core_api, pod)
common.wait_for_volume_healthy(client, volume_name)
volume_file_md5sum1 = get_pod_data_md5sum(core_api, pod_name, data_path1)
assert volume_file_md5sum1 == original_md5sum1
volume_file_md5sum2 = get_pod_data_md5sum(core_api, pod_name, data_path2)
assert volume_file_md5sum2 == original_md5sum2
