def test_restore_no_tsc(bin_cloner_path):
"""Test scenario: restore a snapshot without TSC in current version."""
logger = logging.getLogger("no_tsc_snapshot")
builder = MicrovmBuilder(bin_cloner_path)
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch the v0.24.0 firecracker binary as that one does not have
# the TSC frequency in the snapshot file.
firecracker_artifacts = artifacts.firecrackers(keyword="v0.24.0")
firecracker = firecracker_artifacts[0]
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
diff_snapshots = True
# Create a snapshot.
snapshot = create_snapshot_helper(builder,
logger,
drives=scratch_drives,
ifaces=net_ifaces,
fc_binary=firecracker.local_path(),
jailer_binary=jailer.local_path(),
diff_snapshots=diff_snapshots,
balloon=True)
# Resume microvm using current build of FC/Jailer.
# The resume should be successful because the CPU model
# in the snapshot state is the same as this host's.
microvm, _ = builder.build_from_snapshot(snapshot,
resume=True,
diff_snapshots=False)
validate_all_devices(logger, microvm, net_ifaces, scratch_drives,
diff_snapshots)
logger.debug("========== Firecracker restore snapshot log ==========")
logger.debug(microvm.log_data)
def build_test_matrix(network_config, bin_cloner_path, logger):
"""Build a test matrix using the kernel with the balloon driver."""
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'seq_len': 5
}
# Create the test matrix.
return TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
def test_5_inc_snapshots(network_config, bin_cloner_path):
"""Test scenario: 5 incremental snapshots with disk intensive workload."""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.9/4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_4096mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.DIFF,
'seq_len': 5
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_seq_snapshots)
def test_snap_restore_performance(bin_cloner_path, results_file_dumper):
"""
Test the performance of snapshot restore.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID,
'results_file_dumper': results_file_dumper
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(snapshot_workload)
def test_pause_resume(network_config, bin_cloner_path):
"""Test scenario: boot/pause/resume for all available configurations."""
logger = logging.getLogger("pause_resume")
# Currently, artifacts share the bucket with all other resources.
artifact_collection = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifact_collection.microvms())
kernel_artifacts = ArtifactSet(artifact_collection.kernels())
# Restrict root fs to ubuntu.
disk_artifacts = ArtifactSet(artifact_collection.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_pause_resume)
def test_cmp_full_and_first_diff_mem(network_config, bin_cloner_path):
"""
Compare memory of 2 consecutive full and diff snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_compare_mem_files)
def test_restore_in_past_versions(bin_cloner_path):
"""Test scenario: create a snapshot and restore in previous versions."""
logger = logging.getLogger("snapshot_version")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all snapshots artifacts.
# "fc_release" is the key that should be used for per release snapshot
# artifacts. Such snapshots are created at release time and target the
# current version. We are going to restore all these snapshots with current
# testing build.
firecracker_artifacts = artifacts.firecrackers()
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
# The target version is in the name of the firecracker binary from S3.
# We also strip the "v" as fc expects X.Y.Z version string.
target_version = firecracker.base_name()[1:]
logger.info("Creating snapshot for version: %s", target_version)
# Create a fresh snapshot targeted at the binary artifact version.
snapshot = create_512mb_full_snapshot(bin_cloner_path, target_version)
builder = MicrovmBuilder(bin_cloner_path, firecracker.local_path(),
jailer.local_path())
microvm, _ = builder.build_from_snapshot(snapshot, True, False)
logger.info("Using Firecracker: %s", firecracker.local_path())
logger.info("Using Jailer: %s", jailer.local_path())
# Attempt to connect to resumed microvm.
ssh_connection = net_tools.SSHConnection(microvm.ssh_config)
exit_code, _, _ = ssh_connection.execute_command("sleep 1 && sync")
assert exit_code == 0
def test_api_vsock(bin_cloner_path):
"""
Test vsock related API commands.
@type: functional
"""
builder = MicrovmBuilder(bin_cloner_path)
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Test with the current build.
vm_instance = builder.build_vm_nano()
_test_vsock(vm_instance.vm)
# Fetch 1.0.0 and older firecracker binaries.
# Create a vsock device with each FC binary
# artifact.
firecracker_artifacts = artifacts.firecrackers(
# v1.0.0 deprecated `vsock_id`.
min_version="1.0.0")
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
vm_instance = builder.build_vm_nano(fc_binary=firecracker.local_path(),
jailer_binary=jailer.local_path())
_test_vsock(vm_instance.vm)
def build_from_artifacts(self,
config,
kernel,
disks,
cpu_template,
net_ifaces=None,
diff_snapshots=False,
fc_binary=None,
jailer_binary=None):
"""Spawns a new Firecracker and applies specified config."""
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Pick the first artifact in the set.
config = artifacts.microvms(keyword=config)[0]
kernel = artifacts.kernels(keyword=kernel)[0]
disks = artifacts.disks(keyword=disks)
config.download()
kernel.download()
attached_disks = []
for disk in disks:
disk.download()
attached_disks.append(disk.copy())
# SSH key is attached to root disk artifact.
# Builder will download ssh key in the VM root.
ssh_key = disks[0].ssh_key()
# Create a fresh microvm from artifacts.
return self.build(kernel=kernel,
disks=attached_disks,
ssh_key=ssh_key,
config=config,
net_ifaces=net_ifaces,
diff_snapshots=diff_snapshots,
cpu_template=cpu_template,
fc_binary=fc_binary,
jailer_binary=jailer_binary)
def test_restore_from_past_versions(bin_cloner_path):
"""Test scenario: restore all previous version snapshots."""
logger = logging.getLogger("snapshot_version")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# With each binary create a snapshot and try to restore in current
# version.
firecracker_artifacts = artifacts.firecrackers()
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
logger.info("Source Firecracker: %s", firecracker.local_path())
logger.info("Source Jailer: %s", jailer.local_path())
# Create a fresh snapshot using the binary artifacts.
builder = MicrovmBuilder(bin_cloner_path, firecracker.local_path(),
jailer.local_path())
snapshot = create_512mb_full_snapshot(bin_cloner_path, None,
firecracker.local_path(),
jailer.local_path())
microvm, _ = builder.build_from_snapshot(snapshot, True, False)
ssh_connection = net_tools.SSHConnection(microvm.ssh_config)
exit_code, _, _ = ssh_connection.execute_command("sleep 1 && sync")
assert exit_code == 0
def test_cmp_full_and_first_diff_mem(network_config, bin_cloner_path):
"""Test scenario: cmp memory of 2 consecutive full and diff snapshots."""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.9/4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="vmlinux-4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_compare_mem_files)
def test_older_snapshot_resume_latency(bin_cloner_path, results_file_dumper):
"""
Test scenario: Older snapshot load performance measurement.
@type: performance
"""
logger = logging.getLogger("old_snapshot_load")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# With each binary create a snapshot and try to restore in current
# version.
firecracker_artifacts = ArtifactSet(artifacts.firecrackers(
max_version=get_firecracker_version_from_toml()))
assert len(firecracker_artifacts) > 0
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'name': 'old_snapshot_resume_latency',
'results_file_dumper': results_file_dumper
}
# Create the test matrix.
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
firecracker_artifacts,
microvm_artifacts,
])
test_matrix.run_test(_test_older_snapshot_resume_latency)
def test_mmds_older_snapshot(bin_cloner_path):
"""
Test MMDS behavior restoring older snapshots in the current version.
Ensures that the MMDS version is persisted or initialised with the default
if the FC version does not support this feature.
@type: functional
"""
vm_builder = MicrovmBuilder(bin_cloner_path)
# Validate restoring a past snapshot in the current version.
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
firecracker_artifacts = artifacts.firecrackers(
max_version=get_firecracker_version_from_toml())
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
net_iface = NetIfaceConfig()
vm_instance = vm_builder.build_vm_nano(
net_ifaces=[net_iface],
fc_binary=firecracker.local_path(),
jailer_binary=jailer.local_path()
)
fc_version = firecracker.base_name()[1:]
# If the version is smaller or equal to 1.0.0, we expect that
# MMDS will be initialised with V1 by default.
# Otherwise, we may configure V2.
if compare_versions(fc_version, "1.0.0") <= 0:
mmds_version = "V1"
else:
mmds_version = "V2"
# Check if we need to configure MMDS the old way, by
# setting `allow_mmds_requests`.
# If we do (for v0.25), reissue the network PUT api call.
if compare_versions(fc_version, "1.0.0") < 0:
basevm = vm_instance.vm
guest_mac = net_tools.mac_from_ip(net_iface.guest_ip)
response = basevm.network.put(
iface_id=net_iface.dev_name,
host_dev_name=net_iface.tap_name,
guest_mac=guest_mac,
allow_mmds_requests=True
)
assert basevm.api_session.is_status_no_content(
response.status_code)
_validate_mmds_snapshot(
vm_instance,
vm_builder,
mmds_version,
target_fc_version=fc_version
)
def main():
"""
Run the main logic.
Create snapshot artifacts from complex microVMs with all Firecracker's
functionality enabled. The kernels are parametrized to include all guest
supported versions.
Artifacts are saved in the following format:
snapshot_artifacts
|
-> <guest_kernel_supported_0>_<cpu_template>_guest_snapshot
|
-> vm.mem
-> vm.vmstate
-> ubuntu-18.04.id_rsa
-> ubuntu-18.04.ext4
-> <guest_kernel_supported_1>_<cpu_template>_guest_snapshot
|
...
"""
# Create directory dedicated to store snapshot artifacts for
# each guest kernel version.
shutil.rmtree(SNAPSHOT_ARTIFACTS_ROOT_DIR, ignore_errors=True)
os.mkdir(SNAPSHOT_ARTIFACTS_ROOT_DIR)
root_path = tempfile.mkdtemp(prefix=MicrovmBuilder.ROOT_PREFIX,
dir=f"{DEFAULT_TEST_SESSION_ROOT_PATH}")
# Compile new-pid cloner helper.
bin_cloner_path = compile_file(file_name='newpid_cloner.c',
bin_name='newpid_cloner',
dest_path=root_path)
# Fetch kernel and rootfs artifacts from S3 bucket.
artifacts = ArtifactCollection(_test_images_s3_bucket())
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
cpu_templates = ["None"]
if get_cpu_vendor() == CpuVendor.INTEL:
cpu_templates.extend(["C3", "T2"])
for cpu_template in cpu_templates:
# Create a test context.
test_context = TestContext()
test_context.custom = {
'bin_cloner_path': bin_cloner_path,
'session_root_path': root_path,
'cpu_template': cpu_template
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[kernel_artifacts, disk_artifacts])
test_matrix.run_test(create_snapshots)
def test_restore_old_version(bin_cloner_path):
"""
Restore current snapshot with previous versions of Firecracker.
@type: functional
"""
# Microvm: 2vCPU 256MB RAM, balloon, 4 disks and 4 net devices.
logger = logging.getLogger("old_snapshot_version_many_devices")
builder = MicrovmBuilder(bin_cloner_path)
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# Create a snapshot with current build and restore with each FC binary
# artifact.
firecracker_artifacts = artifacts.firecrackers(
# current snapshot (i.e a machine snapshotted with current build)
# is incompatible with any past release due to notification suppression.
min_version="1.2.0",
max_version=get_firecracker_version_from_toml(),
)
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
logger.info("Creating snapshot with local build")
# Old version from artifact.
target_version = firecracker.base_name()[1:]
# Create a snapshot with current FC version targeting the old version.
snapshot = create_snapshot_helper(
builder,
logger,
target_version=target_version,
drives=scratch_drives,
ifaces=net_ifaces,
balloon=True,
diff_snapshots=True,
)
logger.info("Restoring snapshot with Firecracker: %s",
firecracker.local_path())
logger.info("Using Jailer: %s", jailer.local_path())
# Resume microvm using FC/Jailer binary artifacts.
vm, _ = builder.build_from_snapshot(
snapshot,
resume=True,
diff_snapshots=False,
fc_binary=firecracker.local_path(),
jailer_binary=jailer.local_path(),
)
validate_all_devices(logger, vm, net_ifaces, scratch_drives, True)
logger.debug("========== Firecracker restore snapshot log ==========")
logger.debug(vm.log_data)
def test_restore_old_snapshot(bin_cloner_path):
"""
Restore from snapshots obtained with previous versions of Firecracker.
@type: functional
"""
# Microvm: 2vCPU 256MB RAM, balloon, 4 disks and 4 net devices.
logger = logging.getLogger("old_snapshot_many_devices")
builder = MicrovmBuilder(bin_cloner_path)
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# With each binary create a snapshot and try to restore in current
# version.
firecracker_artifacts = artifacts.firecrackers(
max_version=get_firecracker_version_from_toml())
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
logger.info("Creating snapshot with Firecracker: %s",
firecracker.local_path())
logger.info("Using Jailer: %s", jailer.local_path())
target_version = firecracker.base_name()[1:]
# v0.23 does not support creating diff snapshots.
# v0.23 does not support balloon.
diff_snapshots = "0.23" not in target_version
# Create a snapshot.
snapshot = create_snapshot_helper(
builder,
logger,
drives=scratch_drives,
ifaces=net_ifaces,
fc_binary=firecracker.local_path(),
jailer_binary=jailer.local_path(),
diff_snapshots=diff_snapshots,
balloon=diff_snapshots,
)
# Resume microvm using current build of FC/Jailer.
microvm, _ = builder.build_from_snapshot(snapshot,
resume=True,
diff_snapshots=False)
validate_all_devices(logger, microvm, net_ifaces, scratch_drives,
diff_snapshots)
logger.debug("========== Firecracker restore snapshot log ==========")
logger.debug(microvm.log_data)
def test_mmds_snapshot(bin_cloner_path, version):
"""
Test MMDS behavior by restoring a snapshot on current and past FC versions.
Ensures that the version is persisted or initialised with the default if
the firecracker version does not support it.
@type: functional
"""
vm_builder = MicrovmBuilder(bin_cloner_path)
vm_instance = vm_builder.build_vm_nano(
net_ifaces=[NetIfaceConfig()]
)
# Validate current version.
_validate_mmds_snapshot(
vm_instance, vm_builder, version)
# Validate restoring in past versions.
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# Create a snapshot with current build and restore with each FC binary
# artifact.
firecracker_artifacts = artifacts.firecrackers(
# v1.1.0 breaks snapshot compatibility with older versions.
min_version="1.1.0",
max_version=get_firecracker_version_from_toml())
for firecracker in firecracker_artifacts:
vm_instance = vm_builder.build_vm_nano(
net_ifaces=[NetIfaceConfig()]
)
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
target_version = firecracker.base_name()[1:]
# If the version is smaller or equal to 1.0.0, we expect that
# MMDS will be initialised with V1 by default.
if compare_versions(target_version, "1.0.0") <= 0:
mmds_version = "V1"
else:
mmds_version = version
_validate_mmds_snapshot(
vm_instance,
vm_builder,
mmds_version,
target_fc_version=target_version,
fc_path=firecracker.local_path(),
jailer_path=jailer.local_path()
)
def from_artifacts(cls,
bin_cloner_path,
config,
kernel,
disks,
cpu_template,
start=False,
fc_binary=None,
jailer_binary=None,
net_ifaces=None,
enable_diff_snapshots=False):
"""Spawns a new Firecracker and applies specified config."""
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Pick the first artifact in the set.
config = artifacts.microvms(keyword=config)[0]
kernel = artifacts.kernels(keyword=kernel)[0]
disks = artifacts.disks(keyword=disks)
config.download()
kernel.download()
attached_disks = []
for disk in disks:
disk.download()
attached_disks.append(disk.copy())
vm_builder = MicrovmBuilder(bin_cloner_path, fc_binary, jailer_binary)
# SSH key is attached to root disk artifact.
# Builder will download ssh key in the VM root.
ssh_key = disks[0].ssh_key()
# Create a fresh microvm from aftifacts.
basevm = vm_builder.build(kernel=kernel,
disks=attached_disks,
ssh_key=ssh_key,
config=config,
cpu_template=cpu_template,
net_ifaces=net_ifaces,
enable_diff_snapshots=enable_diff_snapshots)
if start:
basevm.start()
ssh_connection = net_tools.SSHConnection(basevm.ssh_config)
# Verify if we can run commands in guest via ssh.
exit_code, _, _ = ssh_connection.execute_command("sync")
assert exit_code == 0
return VmInstance(config, kernel, attached_disks, ssh_key, basevm)
def test_restore_old_version_all_devices(bin_cloner_path):
"""Test scenario: restore snapshot in previous versions of Firecracker."""
# Microvm: 2vCPU 256MB RAM, baloon, 4 disks and 4 netdevices.
logger = logging.getLogger("snapshot_many_devices")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Fetch all firecracker binaries.
# Create a snapshot with current build and restore with each FC binary
# artifact.
firecracker_artifacts = artifacts.firecrackers()
for firecracker in firecracker_artifacts:
firecracker.download()
jailer = firecracker.jailer()
jailer.download()
logger.info("Creating snapshot with local build")
# Old version from artifact.
target_version = firecracker.base_name()[1:]
# v0.23 does not have a ballon device.
balloon = "0.23" not in target_version
# Create a snapshot with current FC version targeting the old version.
snapshot = create_snapshot_helper(bin_cloner_path,
logger,
target_version=target_version,
drives=scratch_drives,
ifaces=net_ifaces,
balloon=balloon,
diff_snapshots=True)
logger.info("Restoring snapshot with Firecracker: %s",
firecracker.local_path())
logger.info("Using Jailer: %s", jailer.local_path())
# Resume microvm using FC/Jailer binary artifacts.
builder = MicrovmBuilder(bin_cloner_path,
firecracker.local_path(),
jailer.local_path())
microvm, _ = builder.build_from_snapshot(snapshot,
resume=True,
enable_diff_snapshots=False)
validate_all_devices(logger, microvm, net_ifaces, scratch_drives,
balloon)
logger.debug("========== Firecracker restore snapshot log ==========")
logger.debug(microvm.log_data)
def test_network_tcp_throughput(bin_cloner_path, results_file_dumper):
"""Test network throughput driver for multiple artifacts."""
logger = logging.getLogger("network_tcp_throughput")
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="1vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': 'network_tcp_throughput',
'results_file_dumper': results_file_dumper
}
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(iperf_workload)
def test_network_tcp_throughput(bin_cloner_path, results_file_dumper):
"""
Test network throughput for multiple vm confgurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"logger": logger,
"name": TEST_ID,
"results_file_dumper": results_file_dumper,
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(iperf_workload)
def test_block_performance_sync(bin_cloner_path, results_file_dumper):
"""
Test block performance for multiple vm configurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
vm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
vm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID,
'results_file_dumper': results_file_dumper,
'io_engine': 'Sync'
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[vm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(fio_workload)
def test_snapshot_resume_latency(network_config, bin_cloner_path):
"""Test scenario: Snapshot load performance measurement."""
logger = logging.getLogger("snapshot_load")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels(keyword="4.14"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_snapshot_resume_latency)
def test_vsock_throughput(bin_cloner_path):
"""Test vsock throughput driver for multiple artifacts."""
logger = logging.getLogger("vsock_throughput")
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(
artifacts.kernels(keyword="vmlinux-4.14.bin"))
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': 'vsock_throughput'
}
print(get_cpu_model_name())
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(iperf_workload)
def test_block_performance(bin_cloner_path):
"""Test network throughput driver for multiple artifacts."""
logger = logging.getLogger(TEST_ID)
artifacts = ArtifactCollection(_test_images_s3_bucket())
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_1024mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="1vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'logger': logger,
'name': TEST_ID
}
print(f"CPU model: {get_cpu_model_name()}.")
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(fio_workload)
def test_5_inc_snapshots(network_config, bin_cloner_path, bin_vsock_path,
test_fc_session_root_path):
"""
Create and load 5 incremental snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 4096 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_4096mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
"snapshot_type": SnapshotType.DIFF,
"seq_len": 5,
"bin_vsock_path": bin_vsock_path,
"test_fc_session_root_path": test_fc_session_root_path,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_seq_snapshots)
def test_5_full_snapshots(network_config, bin_cloner_path, bin_vsock_path,
test_fc_session_root_path):
"""
Create and load 5 full sequential snapshots.
@type: functional
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.FULL,
'seq_len': 5,
'bin_vsock_path': bin_vsock_path,
'test_fc_session_root_path': test_fc_session_root_path
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts])
test_matrix.run_test(_test_seq_snapshots)
def test_snapshot_create_diff_latency(network_config,
bin_cloner_path,
results_file_dumper):
"""
Test scenario: Diff snapshot create performance measurement.
@type: performance
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: All supported ones
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
'builder': MicrovmBuilder(bin_cloner_path),
'network_config': network_config,
'logger': logger,
'snapshot_type': SnapshotType.DIFF,
'name': 'create_diff_latency',
'results_file_dumper': results_file_dumper
}
# Create the test matrix.
test_matrix = TestMatrix(context=test_context,
artifact_sets=[
microvm_artifacts,
kernel_artifacts,
disk_artifacts
])
test_matrix.run_test(_test_snapshot_create_latency)
def test_snapshot_create_full_latency(network_config, bin_cloner_path,
results_file_dumper):
"""
Test scenario: Full snapshot create performance measurement.
@type: performance
"""
logger = logging.getLogger("snapshot_sequence")
artifacts = ArtifactCollection(_test_images_s3_bucket())
# Testing matrix:
# - Guest kernel: Linux 4.14
# - Rootfs: Ubuntu 18.04
# - Microvm: 2vCPU with 256/512 MB RAM
# TODO: Multiple microvm sizes must be tested in the async pipeline.
microvm_artifacts = ArtifactSet(artifacts.microvms(keyword="2vcpu_512mb"))
microvm_artifacts.insert(artifacts.microvms(keyword="2vcpu_256mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"network_config": network_config,
"logger": logger,
"snapshot_type": SnapshotType.FULL,
"name": "create_full_latency",
"results_file_dumper": results_file_dumper,
}
# Create the test matrix.
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[microvm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(_test_snapshot_create_latency)
def test_block_performance_async(bin_cloner_path, results_file_dumper):
"""
Test block performance for multiple vm configurations.
@type: performance
"""
logger = logging.getLogger(TEST_ID)
if not is_io_uring_supported():
logger.info("io_uring is not supported. Skipping..")
pytest.skip("Cannot run async if io_uring is not supported")
artifacts = ArtifactCollection(_test_images_s3_bucket())
vm_artifacts = ArtifactSet(artifacts.microvms(keyword="1vcpu_1024mb"))
vm_artifacts.insert(artifacts.microvms(keyword="2vcpu_1024mb"))
kernel_artifacts = ArtifactSet(artifacts.kernels())
disk_artifacts = ArtifactSet(artifacts.disks(keyword="ubuntu"))
logger.info("Testing on processor %s", get_cpu_model_name())
# Create a test context and add builder, logger, network.
test_context = TestContext()
test_context.custom = {
"builder": MicrovmBuilder(bin_cloner_path),
"logger": logger,
"name": TEST_ID,
"results_file_dumper": results_file_dumper,
"io_engine": "Async",
}
test_matrix = TestMatrix(
context=test_context,
artifact_sets=[vm_artifacts, kernel_artifacts, disk_artifacts],
)
test_matrix.run_test(fio_workload)
