def test_backup_with_backing_file(backing_dev): # NOQA
dev = backing_dev # NOQA
offset = 0
length = 256
snap0 = cmd.snapshot_create()
before = read_dev(dev, offset, length)
assert before != ""
exists = read_from_backing_file(offset, length)
assert before == exists
backup0 = cmd.backup_create(snap0, BACKUP_DEST)
backup0_info = cmd.backup_inspect(backup0)
assert backup0_info["BackupURL"] == backup0
assert backup0_info["VolumeName"] == VOLUME_NAME
assert backup0_info["VolumeSize"] == VOLUME_SIZE
assert snap0 in backup0_info["SnapshotName"]
test_backup(dev)
cmd.backup_restore(backup0)
after = read_dev(dev, offset, length)
assert before == after
cmd.backup_rm(backup0)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup0)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup0)
assert 'cannot find' in str(e.value)
def backup_test(
dev,
address, # NOQA
volume_name,
engine_name,
backup_target):
offset = 0
length = 128
snap1_data = random_string(length)
verify_data(dev, offset, snap1_data)
snap1_checksum = checksum_dev(dev)
snap1 = cmd.snapshot_create(address)
backup1_info = create_backup(address, snap1, backup_target)
assert backup1_info["VolumeName"] == volume_name
assert backup1_info["Size"] == BLOCK_SIZE_STR
snap2_data = random_string(length)
verify_data(dev, offset, snap2_data)
snap2_checksum = checksum_dev(dev)
snap2 = cmd.snapshot_create(address)
backup2_info = create_backup(address, snap2, backup_target)
assert backup2_info["VolumeName"] == volume_name
assert backup2_info["Size"] == BLOCK_SIZE_STR
snap3_data = random_string(length)
verify_data(dev, offset, snap3_data)
snap3_checksum = checksum_dev(dev)
snap3 = cmd.snapshot_create(address)
backup3_info = create_backup(address, snap3, backup_target)
assert backup3_info["VolumeName"] == volume_name
assert backup3_info["Size"] == BLOCK_SIZE_STR
restore_with_frontend(address, engine_name, backup3_info["URL"])
readed = read_dev(dev, offset, length)
assert readed == snap3_data
c = checksum_dev(dev)
assert c == snap3_checksum
rm_backups(address, engine_name, [backup3_info["URL"]])
restore_with_frontend(address, engine_name, backup1_info["URL"])
readed = read_dev(dev, offset, length)
assert readed == snap1_data
c = checksum_dev(dev)
assert c == snap1_checksum
rm_backups(address, engine_name, [backup1_info["URL"]])
restore_with_frontend(address, engine_name, backup2_info["URL"])
readed = read_dev(dev, offset, length)
assert readed == snap2_data
c = checksum_dev(dev)
assert c == snap2_checksum
rm_backups(address, engine_name, [backup2_info["URL"]])
def test_snapshot_revert(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 in snapList
assert snap2 in snapList
assert snap3 in snapList
cmd.snapshot_revert(snap2)
readed = read_dev(dev, offset, length)
assert readed == snap2_data
cmd.snapshot_revert(snap1)
readed = read_dev(dev, offset, length)
assert readed == snap1_data
def backup_with_backing_file_test(
backup_target, # NOQA
grpc_backing_controller, # NOQA
grpc_backing_replica1, # NOQA
grpc_backing_replica2): # NOQA
address = grpc_backing_controller.address
dev = get_backing_dev(grpc_backing_replica1, grpc_backing_replica2,
grpc_backing_controller)
offset = 0
length = 256
snap0 = cmd.snapshot_create(address)
before = read_dev(dev, offset, length)
assert before != ""
snap0_checksum = checksum_dev(dev)
exists = read_from_backing_file(offset, length)
assert before == exists
backup0_info = create_backup(address, snap0, backup_target)
assert backup0_info["VolumeName"] == VOLUME_BACKING_NAME
backup_test(dev, address, VOLUME_BACKING_NAME, ENGINE_BACKING_NAME,
backup_target)
restore_with_frontend(address, ENGINE_BACKING_NAME, backup0_info["URL"])
after = read_dev(dev, offset, length)
assert before == after
c = checksum_dev(dev)
assert c == snap0_checksum
rm_backups(address, ENGINE_BACKING_NAME, [backup0_info["URL"]])
def test_snapshot_revert_with_backing_file(
grpc_backing_controller, # NOQA
grpc_backing_replica1, # NOQA
grpc_backing_replica2): # NOQA
address = grpc_backing_controller.address
dev = get_backing_dev(grpc_backing_replica1, grpc_backing_replica2,
grpc_backing_controller)
offset = 0
length = 256
snap0 = cmd.snapshot_create(address)
before = read_dev(dev, offset, length)
assert before != ""
info = cmd.snapshot_info(address)
assert len(info) == 2
assert VOLUME_HEAD in info
assert snap0 in info
exists = read_from_backing_file(offset, length)
assert before == exists
snapshot_revert_test(dev, address, ENGINE_BACKING_NAME)
snapshot_revert_with_frontend(address, ENGINE_BACKING_NAME, snap0)
after = read_dev(dev, offset, length)
assert before == after
def backup_with_backing_file_test(backing_dev, backup_target): # NOQA
dev = backing_dev # NOQA
offset = 0
length = 256
snap0 = cmd.snapshot_create()
before = read_dev(dev, offset, length)
assert before != ""
snap0_checksum = common.checksum_dev(dev)
exists = read_from_backing_file(offset, length)
assert before == exists
backup0 = cmd.backup_create(snap0, backup_target)
backup0_info = cmd.backup_inspect(backup0)
assert backup0_info["URL"] == backup0
assert backup0_info["VolumeName"] == VOLUME_NAME
assert backup0_info["VolumeSize"] == VOLUME_SIZE
assert snap0 in backup0_info["SnapshotName"]
backup_test(dev, backup_target)
cmd.backup_restore(backup0)
after = read_dev(dev, offset, length)
assert before == after
c = common.checksum_dev(dev)
assert c == snap0_checksum
cmd.backup_rm(backup0)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup0)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_inspect(backup0)
def test_backup_with_backing_file(backing_dev): # NOQA
dev = backing_dev # NOQA
offset = 0
length = 256
snap0 = cmd.snapshot_create()
before = read_dev(dev, offset, length)
assert before != ""
snap0_checksum = common.checksum_dev(dev)
exists = read_from_backing_file(offset, length)
assert before == exists
backup0 = cmd.backup_create(snap0, BACKUP_DEST)
backup0_info = cmd.backup_inspect(backup0)
assert backup0_info["URL"] == backup0
assert backup0_info["VolumeName"] == VOLUME_NAME
assert backup0_info["VolumeSize"] == VOLUME_SIZE
assert snap0 in backup0_info["SnapshotName"]
test_backup(dev)
cmd.backup_restore(backup0)
after = read_dev(dev, offset, length)
assert before == after
c = common.checksum_dev(dev)
assert c == snap0_checksum
cmd.backup_rm(backup0)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup0)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup0)
assert 'cannot find' in str(e.value)
def backup_hole_with_backing_file_test(
backup_target, # NOQA
grpc_backing_controller, # NOQA
grpc_backing_replica1, # NOQA
grpc_backing_replica2): # NOQA
address = grpc_backing_controller.address
dev = get_backing_dev(grpc_backing_replica1, grpc_backing_replica2,
grpc_backing_controller)
offset1 = 512
length1 = 256
offset2 = 640
length2 = 256
boundary_offset = 0
boundary_length = 4100 # just pass 4096 into next 4k
hole_offset = 2 * 1024 * 1024
hole_length = 1024
snap1_data = random_string(length1)
verify_data(dev, offset1, snap1_data)
snap1_checksum = checksum_dev(dev)
snap1 = cmd.snapshot_create(address)
boundary_data_backup1 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup1 = read_dev(dev, hole_offset, hole_length)
backup1_info = create_backup(address, snap1, backup_target)
snap2_data = random_string(length2)
verify_data(dev, offset2, snap2_data)
snap2_checksum = checksum_dev(dev)
snap2 = cmd.snapshot_create(address)
boundary_data_backup2 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup2 = read_dev(dev, hole_offset, hole_length)
backup2_info = create_backup(address, snap2, backup_target)
restore_with_frontend(address, ENGINE_BACKING_NAME, backup1_info["URL"])
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup1
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup1
c = checksum_dev(dev)
assert c == snap1_checksum
restore_with_frontend(address, ENGINE_BACKING_NAME, backup2_info["URL"])
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup2
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup2
c = checksum_dev(dev)
assert c == snap2_checksum
def test_snapshot_revert_with_backing_file(backing_dev): # NOQA
dev = backing_dev # NOQA
offset = 0
length = 256
snap0 = cmd.snapshot_create()
before = read_dev(dev, offset, length)
assert before != ""
exists = read_from_backing_file(offset, length)
assert before == exists
test_snapshot_revert(dev)
cmd.snapshot_revert(snap0)
after = read_dev(dev, offset, length)
assert before == after
def test_beyond_boundary(dev): # NOQA
# check write at the boundary
data = common.random_string(128)
common.verify_data(dev, SIZE - 128, data)
# out of bounds
with pytest.raises(cattle.ApiError) as err:
write_dev(dev, SIZE, "1")
assert 'EOF' in str(err.value)
with pytest.raises(cattle.ApiError) as err:
read_dev(dev, SIZE, 1)
assert 'EOF' in str(err.value)
# normal writes to verify controller/replica survival
for i in range(0, 10):
offset = random.randint(0, SIZE - 256)
length = random.randint(0, 256)
data = common.random_string(length)
common.verify_data(dev, offset, data)
def test_beyond_boundary(dev): # NOQA
# check write at the boundary
data = common.random_string(128)
common.verify_data(dev, SIZE - 128, data)
# out of bounds
with pytest.raises(EnvironmentError) as err:
write_dev(dev, SIZE, "1")
assert 'No space left' in str(err.value)
assert len(read_dev(dev, SIZE, 1)) == 0
# normal writes to verify controller/replica survival
test_basic_rw(dev)
def test_beyond_boundary(dev): # NOQA
# check write at the boundary
data = common.random_string(128)
common.verify_data(dev, SIZE - 128, data)
# out of bounds
with pytest.raises(EnvironmentError) as err:
write_dev(dev, SIZE, "1")
assert 'No space left' in str(err.value)
assert len(read_dev(dev, SIZE, 1)) == 0
# normal writes to verify controller/replica survival
test_basic_rw(dev)
def backup_hole_with_backing_file_test(backing_dev, backup_target): # NOQA
dev = backing_dev # NOQA
offset1 = 512
length1 = 256
offset2 = 640
length2 = 256
boundary_offset = 0
boundary_length = 4100 # just pass 4096 into next 4k
hole_offset = 2 * 1024 * 1024
hole_length = 1024
snap1_data = common.random_string(length1)
common.verify_data(dev, offset1, snap1_data)
snap1_checksum = common.checksum_dev(dev)
snap1 = cmd.snapshot_create()
boundary_data_backup1 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup1 = read_dev(dev, hole_offset, hole_length)
backup1 = cmd.backup_create(snap1, backup_target)
snap2_data = common.random_string(length2)
common.verify_data(dev, offset2, snap2_data)
snap2_checksum = common.checksum_dev(dev)
snap2 = cmd.snapshot_create()
boundary_data_backup2 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup2 = read_dev(dev, hole_offset, hole_length)
backup2 = cmd.backup_create(snap2, backup_target)
cmd.backup_restore(backup1)
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup1
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup1
c = common.checksum_dev(dev)
assert c == snap1_checksum
cmd.backup_restore(backup2)
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup2
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup2
c = common.checksum_dev(dev)
assert c == snap2_checksum
def test_backup_hole_with_backing_file(backing_dev): # NOQA
dev = backing_dev # NOQA
offset1 = 512
length1 = 256
offset2 = 640
length2 = 256
boundary_offset = 0
boundary_length = 4100 # just pass 4096 into next 4k
hole_offset = 2 * 1024 * 1024
hole_length = 1024
snap1_data = common.random_string(length1)
common.verify_data(dev, offset1, snap1_data)
snap1_checksum = common.checksum_dev(dev)
snap1 = cmd.snapshot_create()
boundary_data_backup1 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup1 = read_dev(dev, hole_offset, hole_length)
backup1 = cmd.backup_create(snap1, BACKUP_DEST)
snap2_data = common.random_string(length2)
common.verify_data(dev, offset2, snap2_data)
snap2_checksum = common.checksum_dev(dev)
snap2 = cmd.snapshot_create()
boundary_data_backup2 = read_dev(dev, boundary_offset, boundary_length)
hole_data_backup2 = read_dev(dev, hole_offset, hole_length)
backup2 = cmd.backup_create(snap2, BACKUP_DEST)
cmd.backup_restore(backup1)
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup1
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup1
c = common.checksum_dev(dev)
assert c == snap1_checksum
cmd.backup_restore(backup2)
readed = read_dev(dev, boundary_offset, boundary_length)
assert readed == boundary_data_backup2
readed = read_dev(dev, hole_offset, hole_length)
assert readed == hole_data_backup2
c = common.checksum_dev(dev)
assert c == snap2_checksum
def test_snapshot_revert_with_backing_file(backing_dev): # NOQA
dev = backing_dev # NOQA
offset = 0
length = 256
snap0 = cmd.snapshot_create()
before = read_dev(dev, offset, length)
assert before != ""
info = cmd.snapshot_info()
assert len(info) == 2
assert VOLUME_HEAD in info
assert snap0 in info
exists = read_from_backing_file(offset, length)
assert before == exists
test_snapshot_revert(dev)
cmd.snapshot_revert(snap0)
after = read_dev(dev, offset, length)
assert before == after
def test_snapshot_rm_basic(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
info = cmd.snapshot_info()
assert len(info) == 4
assert VOLUME_HEAD in info
assert snap1 in info
assert snap2 in info
assert snap3 in info
cmd.snapshot_rm(snap2)
cmd.snapshot_purge()
info = cmd.snapshot_info()
assert len(info) == 3
assert snap1 in info
assert snap3 in info
readed = read_dev(dev, offset, length)
assert readed == snap3_data
cmd.snapshot_revert(snap1)
readed = read_dev(dev, offset, length)
assert readed == snap1_data
def test_snapshot_rm_rolling(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 in snapList
cmd.snapshot_rm(snap1)
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 not in snapList
assert snap2 in snapList
# this should trigger real deletion of snap1
cmd.snapshot_rm(snap2)
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
snap4_data = common.random_string(length)
common.verify_data(dev, offset, snap4_data)
snap4 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 not in snapList
assert snap2 not in snapList
assert snap3 in snapList
assert snap4 in snapList
output = cmd.snapshot_info()
info = json.loads(output)
assert info[snap3]["size"] == "4096"
assert info[snap4]["size"] == "4096"
# this should trigger real deletion of snap2 and snap3
cmd.snapshot_rm(snap3)
readed = read_dev(dev, offset, length)
assert readed == snap4_data
def test_snapshot_rm_rolling(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 in snapList
cmd.snapshot_rm(snap1)
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 not in snapList
assert snap2 in snapList
# this should trigger real deletion of snap1
cmd.snapshot_rm(snap2)
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
snap4_data = common.random_string(length)
common.verify_data(dev, offset, snap4_data)
snap4 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 not in snapList
assert snap2 not in snapList
assert snap3 in snapList
assert snap4 in snapList
# this should trigger real deletion of snap2 and snap3
cmd.snapshot_rm(snap3)
readed = read_dev(dev, offset, length)
assert readed == snap4_data
def restore_to_file_with_backing_file_test(
backup_target, # NOQA
grpc_backing_controller, # NOQA
grpc_backing_replica1, # NOQA
grpc_backing_replica2): # NOQA
address = grpc_backing_controller.address
backing_dev = get_backing_dev(grpc_backing_replica1, grpc_backing_replica2,
grpc_backing_controller)
length0 = 4 * 1024
length1 = 256
length2 = 128
offset0 = 0
offset1 = length1 + offset0
offset2 = length2 + offset0
output_raw_path = file(OUTPUT_FILE_RAW)
output_qcow2_path = file(OUTPUT_FILE_QCOW2)
# create 1 empty snapshot.
# data in output image == data in backing
check_backing()
check_empty_volume(backing_dev)
snap0 = cmd.snapshot_create(address)
backup = create_backup(address, snap0, backup_target)["URL"]
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(offset0, length0)
dev_checksum = checksum_dev(backing_dev)
assert volume_data != ""
assert volume_data == backing_data
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_raw_path, IMAGE_FORMAT_RAW)
output0_raw = read_file(output_raw_path, offset0, length0)
output0_checksum = checksum_data(read_file(output_raw_path, 0, SIZE))
assert output0_raw == backing_data
assert output0_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output0_qcow2 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length0)
output0_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output0_qcow2 == backing_data
assert output0_qcow2 == volume_data
assert output0_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
rm_backups(address, ENGINE_BACKING_NAME, [backup])
# create 1 snapshot with 256B data.
# output = snap1(offset0, length1) + backing(offset1, ...)
snap1_data = random_string(length1)
verify_data(backing_dev, offset0, snap1_data)
snap1 = cmd.snapshot_create(address)
backup = create_backup(address, snap1, backup_target)["URL"]
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(offset1, length0 - offset1)
dev_checksum = checksum_dev(backing_dev)
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_raw_path, IMAGE_FORMAT_RAW)
output1_raw_snap1 = read_file(output_raw_path, offset0, length1)
output1_raw_backing = read_file(output_raw_path, offset1,
length0 - offset1)
output1_checksum = checksum_data(read_file(output_raw_path, 0, SIZE))
assert output1_raw_snap1 == snap1_data
assert output1_raw_backing == backing_data
assert output1_raw_snap1 + output1_raw_backing == volume_data
assert output1_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output1_qcow2_snap1 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length1)
output1_qcow2_backing = read_qcow2_file_without_backing_file(
output_qcow2_path, offset1, length0 - offset1)
output1_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output1_qcow2_snap1 == snap1_data
assert output1_qcow2_backing == backing_data
assert output1_qcow2_snap1 + output1_qcow2_backing == volume_data
assert output1_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
snapshot_revert_with_frontend(address, ENGINE_BACKING_NAME, snap0)
rm_snaps(address, [snap1])
rm_backups(address, ENGINE_BACKING_NAME, [backup])
check_backing()
check_empty_volume(backing_dev)
# create 2 snapshots with 256B data and 128B data
# output = snap2(offset0, length1 - length2) +
# snap1(offset2, length2) + backing(offset2, ...)
snap1_data = random_string(length1)
verify_data(backing_dev, offset0, snap1_data)
snap1 = cmd.snapshot_create(address)
snap2_data = random_string(length2)
verify_data(backing_dev, offset0, snap2_data)
snap2 = cmd.snapshot_create(address)
backup = create_backup(address, snap2, backup_target)["URL"]
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(offset1, length0 - offset1)
dev_checksum = checksum_dev(backing_dev)
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_raw_path, IMAGE_FORMAT_RAW)
output2_raw_snap2 = read_file(output_raw_path, offset0, length2)
output2_raw_snap1 = read_file(output_raw_path, offset2, length1 - length2)
output2_raw_backing = read_file(output_raw_path, offset1,
length0 - offset1)
output2_checksum = checksum_data(read_file(output_raw_path, 0, SIZE))
assert output2_raw_snap2 == snap2_data
assert output2_raw_snap1 == snap1_data[offset2:length1]
assert output2_raw_backing == backing_data
assert \
volume_data == \
output2_raw_snap2 + output2_raw_snap1 + output2_raw_backing
assert output2_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(address, backup, file(BACKING_FILE_QCOW),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output2_qcow2_snap2 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length2)
output2_qcow2_snap1 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset2, length1 - length2)
output2_qcow2_backing = read_qcow2_file_without_backing_file(
output_qcow2_path, offset1, length0 - offset1)
output2_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output2_qcow2_snap2 == snap2_data
assert output2_qcow2_snap1 == snap1_data[offset2:length1]
assert output2_qcow2_backing == backing_data
assert \
volume_data == \
output2_qcow2_snap2 + output2_qcow2_snap1 + output1_qcow2_backing
assert output2_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
snapshot_revert_with_frontend(address, ENGINE_BACKING_NAME, snap0)
rm_snaps(address, [snap1, snap2])
rm_backups(address, ENGINE_BACKING_NAME, [backup])
check_backing()
check_empty_volume(backing_dev)
def test_snapshot_rm_rolling(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 in snapList
cmd.snapshot_rm(snap1)
# cannot do anything because it's the parent of volume head
cmd.snapshot_purge()
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
info = cmd.snapshot_info()
assert len(info) == 3
assert snap1 in info
assert info[snap1]["removed"] is True
assert snap2 in info
assert info[snap2]["removed"] is False
cmd.snapshot_rm(snap2)
# this should trigger the deletion of snap1
cmd.snapshot_purge()
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
snap4_data = common.random_string(length)
common.verify_data(dev, offset, snap4_data)
snap4 = cmd.snapshot_create()
snap5_data = common.random_string(length)
common.verify_data(dev, offset, snap5_data)
snap5 = cmd.snapshot_create()
snapList = cmd.snapshot_ls()
assert snap1 not in snapList
assert snap2 not in snapList
assert snap3 in snapList
assert snap4 in snapList
assert snap5 in snapList
info = cmd.snapshot_info()
assert len(info) == 5
assert snap1 not in info
assert snap2 in info
assert info[snap2]["removed"] is True
assert snap3 in info
assert info[snap3]["size"] == "4096"
assert snap4 in info
assert info[snap4]["size"] == "4096"
assert snap5 in info
assert info[snap5]["size"] == "4096"
cmd.snapshot_rm(snap3)
cmd.snapshot_rm(snap4)
cmd.snapshot_rm(snap5)
# this should trigger the deletion of snap2 - snap4
# and snap5 marked as removed
cmd.snapshot_purge()
info = cmd.snapshot_info()
assert len(info) == 2
assert snap1 not in info
assert snap2 not in info
assert snap3 not in info
assert snap4 not in info
assert snap5 in info
assert info[snap5]["removed"] is True
assert info[snap5]["size"] == "4096"
readed = read_dev(dev, offset, length)
assert readed == snap5_data
def snapshot_tree_verify_backup_node(dev, offset, length, backup, data, name):
cmd.backup_restore(backup[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
def snapshot_tree_verify_node(dev, offset, length, snap, data, name):
cmd.snapshot_revert(snap[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
def test_backup(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1 = cmd.snapshot_create()
backup1 = cmd.backup_create(snap1, BACKUP_DEST)
backup1_info = cmd.backup_inspect(backup1)
assert backup1_info["BackupURL"] == backup1
assert backup1_info["VolumeName"] == VOLUME_NAME
assert backup1_info["VolumeSize"] == VOLUME_SIZE
assert snap1 in backup1_info["SnapshotName"]
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2 = cmd.snapshot_create()
backup2 = cmd.backup_create(snap2, BACKUP_DEST)
backup2_info = cmd.backup_inspect(backup2)
assert backup2_info["BackupURL"] == backup2
assert backup2_info["VolumeName"] == VOLUME_NAME
assert backup2_info["VolumeSize"] == VOLUME_SIZE
assert snap2 in backup2_info["SnapshotName"]
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3 = cmd.snapshot_create()
backup3 = cmd.backup_create(snap3, BACKUP_DEST)
backup3_info = cmd.backup_inspect(backup3)
assert backup3_info["BackupURL"] == backup3
assert backup3_info["VolumeName"] == VOLUME_NAME
assert backup3_info["VolumeSize"] == VOLUME_SIZE
assert snap3 in backup3_info["SnapshotName"]
cmd.backup_restore(backup3)
readed = read_dev(dev, offset, length)
assert readed == snap3_data
cmd.backup_rm(backup3)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup3)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup3)
assert 'cannot find' in str(e.value)
cmd.backup_restore(backup1)
readed = read_dev(dev, offset, length)
assert readed == snap1_data
cmd.backup_rm(backup1)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup1)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup1)
assert 'cannot find' in str(e.value)
cmd.backup_restore(backup2)
readed = read_dev(dev, offset, length)
assert readed == snap2_data
cmd.backup_rm(backup2)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup2)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup2)
assert 'cannot find' in str(e.value)
def restore_to_file_with_backing_file_test(backing_dev, backup_target):
length0 = 4 * 1024
length1 = 256
length2 = 128
offset0 = 0
offset1 = length1 + offset0
offset2 = length2 + offset0
output_raw_path = file(OUTPUT_FILE_RAW)
output_qcow2_path = file(OUTPUT_FILE_QCOW2)
# create 1 empty snapshot.
# data in output image == data in backing
check_backing()
check_empty_volume(backing_dev)
snap0 = cmd.snapshot_create()
backup = create_backup(backup_target, snap0)
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(offset0, length0)
dev_checksum = common.checksum_dev(backing_dev)
assert volume_data != ""
assert volume_data == backing_data
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_raw_path, IMAGE_FORMAT_RAW)
output0_raw = read_file(output_raw_path, offset0, length0)
output0_checksum = checksum_data(
read_file(output_raw_path, 0, SIZE))
assert output0_raw == backing_data
assert output0_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output0_qcow2 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length0)
output0_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output0_qcow2 == backing_data
assert output0_qcow2 == volume_data
assert output0_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
rm_backups([backup])
# create 1 snapshot with 256B data.
# output = snap1(offset0, length1) + backing(offset1, ...)
snap1_data = common.random_string(length1)
common.verify_data(backing_dev, offset0, snap1_data)
snap1 = cmd.snapshot_create()
backup = create_backup(backup_target, snap1)
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(
offset1, length0 - offset1)
dev_checksum = common.checksum_dev(backing_dev)
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_raw_path, IMAGE_FORMAT_RAW)
output1_raw_snap1 = read_file(
output_raw_path, offset0, length1)
output1_raw_backing = read_file(
output_raw_path, offset1, length0 - offset1)
output1_checksum = checksum_data(
read_file(output_raw_path, 0, SIZE))
assert output1_raw_snap1 == snap1_data
assert output1_raw_backing == backing_data
assert output1_raw_snap1 + output1_raw_backing == volume_data
assert output1_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output1_qcow2_snap1 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length1)
output1_qcow2_backing = read_qcow2_file_without_backing_file(
output_qcow2_path, offset1, length0 - offset1)
output1_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output1_qcow2_snap1 == snap1_data
assert output1_qcow2_backing == backing_data
assert output1_qcow2_snap1 + output1_qcow2_backing == volume_data
assert output1_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
cmd.snapshot_revert(snap0)
rm_snaps([snap1])
rm_backups([backup])
check_backing()
check_empty_volume(backing_dev)
# create 2 snapshots with 256B data and 128B data
# output = snap2(offset0, length1 - length2) +
# snap1(offset2, length2) + backing(offset2, ...)
snap1_data = common.random_string(length1)
common.verify_data(backing_dev, offset0, snap1_data)
snap1 = cmd.snapshot_create()
snap2_data = common.random_string(length2)
common.verify_data(backing_dev, offset0, snap2_data)
snap2 = cmd.snapshot_create()
backup = create_backup(backup_target, snap2)
volume_data = read_dev(backing_dev, offset0, length0)
backing_data = read_from_backing_file(
offset1, length0 - offset1)
dev_checksum = common.checksum_dev(backing_dev)
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_raw_path, IMAGE_FORMAT_RAW)
output2_raw_snap2 = read_file(
output_raw_path, offset0, length2)
output2_raw_snap1 = read_file(
output_raw_path, offset2, length1 - length2)
output2_raw_backing = read_file(
output_raw_path, offset1, length0 - offset1)
output2_checksum = checksum_data(
read_file(output_raw_path, 0, SIZE))
assert output2_raw_snap2 == snap2_data
assert output2_raw_snap1 == snap1_data[offset2: length1]
assert output2_raw_backing == backing_data
assert \
volume_data == \
output2_raw_snap2 + output2_raw_snap1 + output2_raw_backing
assert output2_checksum == dev_checksum
os.remove(output_raw_path)
assert not os.path.exists(output_raw_path)
cmd.restore_to_file(backup, file(BACKING_FILE_QCOW2),
output_qcow2_path, IMAGE_FORMAT_QCOW2)
output2_qcow2_snap2 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset0, length2)
output2_qcow2_snap1 = read_qcow2_file_without_backing_file(
output_qcow2_path, offset2, length1 - length2)
output2_qcow2_backing = read_qcow2_file_without_backing_file(
output_qcow2_path, offset1, length0 - offset1)
output2_checksum = checksum_data(
read_qcow2_file_without_backing_file(output_qcow2_path, 0, SIZE))
assert output2_qcow2_snap2 == snap2_data
assert output2_qcow2_snap1 == snap1_data[offset2: length1]
assert output2_qcow2_backing == backing_data
assert \
volume_data == \
output2_qcow2_snap2 + output2_qcow2_snap1 + output1_qcow2_backing
assert output2_checksum == dev_checksum
os.remove(output_qcow2_path)
assert not os.path.exists(output_qcow2_path)
cmd.snapshot_revert(snap0)
rm_snaps([snap1, snap2])
rm_backups([backup])
check_backing()
check_empty_volume(backing_dev)
def snapshot_tree_verify_backup_node(dev, address, engine_name, offset, length,
backup, data, name):
restore_with_frontend(address, engine_name, backup[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
def test_backup(dev): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1_checksum = common.checksum_dev(dev)
snap1 = cmd.snapshot_create()
backup1 = cmd.backup_create(snap1, BACKUP_DEST)
backup1_info = cmd.backup_inspect(backup1)
assert backup1_info["URL"] == backup1
assert backup1_info["VolumeName"] == VOLUME_NAME
assert backup1_info["VolumeSize"] == VOLUME_SIZE
assert backup1_info["Size"] == BLOCK_SIZE
assert snap1 in backup1_info["SnapshotName"]
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2_checksum = common.checksum_dev(dev)
snap2 = cmd.snapshot_create()
backup2 = cmd.backup_create(snap2, BACKUP_DEST)
backup2_info = cmd.backup_inspect(backup2)
assert backup2_info["URL"] == backup2
assert backup2_info["VolumeName"] == VOLUME_NAME
assert backup2_info["VolumeSize"] == VOLUME_SIZE
assert backup2_info["Size"] == BLOCK_SIZE
assert snap2 in backup2_info["SnapshotName"]
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3_checksum = common.checksum_dev(dev)
snap3 = cmd.snapshot_create()
backup3 = cmd.backup_create(snap3, BACKUP_DEST)
backup3_info = cmd.backup_inspect(backup3)
assert backup3_info["URL"] == backup3
assert backup3_info["VolumeName"] == VOLUME_NAME
assert backup3_info["VolumeSize"] == VOLUME_SIZE
assert backup3_info["Size"] == BLOCK_SIZE
assert snap3 in backup3_info["SnapshotName"]
cmd.backup_restore(backup3)
readed = read_dev(dev, offset, length)
assert readed == snap3_data
c = common.checksum_dev(dev)
assert c == snap3_checksum
cmd.backup_rm(backup3)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup3)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup3)
assert 'cannot find' in str(e.value)
cmd.backup_restore(backup1)
readed = read_dev(dev, offset, length)
assert readed == snap1_data
c = common.checksum_dev(dev)
assert c == snap1_checksum
cmd.backup_rm(backup1)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup1)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup1)
assert 'cannot find' in str(e.value)
cmd.backup_restore(backup2)
readed = read_dev(dev, offset, length)
assert readed == snap2_data
c = common.checksum_dev(dev)
assert c == snap2_checksum
cmd.backup_rm(backup2)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup2)
with pytest.raises(subprocess.CalledProcessError) as e:
cmd.backup_inspect(backup2)
assert 'cannot find' in str(e.value)
def snapshot_tree_verify_backup_node(dev, offset, length, backup, data, name):
cmd.backup_restore(backup[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
def snapshot_tree_verify_node(dev, offset, length, snap, data, name):
cmd.snapshot_revert(snap[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
def backup_test(dev, backup_target): # NOQA
offset = 0
length = 128
snap1_data = common.random_string(length)
common.verify_data(dev, offset, snap1_data)
snap1_checksum = common.checksum_dev(dev)
snap1 = cmd.snapshot_create()
backup1 = cmd.backup_create(snap1, backup_target)
backup1_info = cmd.backup_inspect(backup1)
assert backup1_info["URL"] == backup1
assert backup1_info["VolumeName"] == VOLUME_NAME
assert backup1_info["VolumeSize"] == VOLUME_SIZE
assert backup1_info["Size"] == BLOCK_SIZE
assert snap1 in backup1_info["SnapshotName"]
snap2_data = common.random_string(length)
common.verify_data(dev, offset, snap2_data)
snap2_checksum = common.checksum_dev(dev)
snap2 = cmd.snapshot_create()
backup2 = cmd.backup_create(snap2, backup_target)
backup2_info = cmd.backup_inspect(backup2)
assert backup2_info["URL"] == backup2
assert backup2_info["VolumeName"] == VOLUME_NAME
assert backup2_info["VolumeSize"] == VOLUME_SIZE
assert backup2_info["Size"] == BLOCK_SIZE
assert snap2 in backup2_info["SnapshotName"]
snap3_data = common.random_string(length)
common.verify_data(dev, offset, snap3_data)
snap3_checksum = common.checksum_dev(dev)
snap3 = cmd.snapshot_create()
backup3 = cmd.backup_create(snap3, backup_target)
backup3_info = cmd.backup_inspect(backup3)
assert backup3_info["URL"] == backup3
assert backup3_info["VolumeName"] == VOLUME_NAME
assert backup3_info["VolumeSize"] == VOLUME_SIZE
assert backup3_info["Size"] == BLOCK_SIZE
assert snap3 in backup3_info["SnapshotName"]
cmd.backup_restore(backup3)
readed = read_dev(dev, offset, length)
assert readed == snap3_data
c = common.checksum_dev(dev)
assert c == snap3_checksum
cmd.backup_rm(backup3)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup3)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_inspect(backup3)
cmd.backup_restore(backup1)
readed = read_dev(dev, offset, length)
assert readed == snap1_data
c = common.checksum_dev(dev)
assert c == snap1_checksum
cmd.backup_rm(backup1)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup1)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_inspect(backup1)
cmd.backup_restore(backup2)
readed = read_dev(dev, offset, length)
assert readed == snap2_data
c = common.checksum_dev(dev)
assert c == snap2_checksum
cmd.backup_rm(backup2)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_restore(backup2)
with pytest.raises(subprocess.CalledProcessError):
cmd.backup_inspect(backup2)
def check_empty_volume(dev, offset=0, length=4*1024):
backing_data = read_from_backing_file(offset, length)
empty_volume_data = read_dev(dev, offset, length)
assert backing_data == empty_volume_data
def snapshot_tree_verify_node(dev, address, engine_name, offset, length, snap,
data, name):
snapshot_revert_with_frontend(address, engine_name, snap[name])
readed = read_dev(dev, offset, length)
assert readed == data[name]
