1
0
Fork 0
mirror of https://github.com/retspen/webvirtcloud synced 2026-11-11 12:46:49 +00:00

test: each app keeps its tests in a tests package

131 test modules sat next to the code they test; instances alone had
51 of them beside views.py and utils.py. They move into a
tests/ package per app, and the JavaScript checks into
webvirtcloud/tests/js. Each non-empty tests.py becomes tests/test_views.py;
the empty generated stubs are removed.

Imports of the app's own modules become absolute, paths built from
__file__ go one level up, the live helper is instances.tests.livetest,
and coverage omits */tests/*. The suite discovers the same 960 tests as
before.
This commit is contained in:
catborise 2026-10-12 10:37:29 +03:00
parent 0906838193
commit c55f52f025
154 changed files with 27 additions and 39 deletions

View file

127
instances/tests/livetest.py Normal file
View file

@ -0,0 +1,127 @@
"""Safety helpers for the live libvirt test suite.
Everything the suite creates is named with PREFIX, and its volumes live
in a dedicated pool. Cleanup only removes prefixed domains and the
volumes of that pool, so a broken test cannot delete other VMs or images
on a shared host. inventory() lets a suite check that nothing else
changed.
"""
import os
import libvirt
PREFIX = "wvc-test-"
POOL = "wvc-test"
POOL_PATH = "/var/lib/libvirt/wvc-test"
UNDEFINE_FLAGS = (
libvirt.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE
| libvirt.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA
| libvirt.VIR_DOMAIN_UNDEFINE_NVRAM
| libvirt.VIR_DOMAIN_UNDEFINE_CHECKPOINTS_METADATA
)
def enabled():
"""The suite creates and deletes VMs, so it only runs on an explicitly named host."""
return bool(os.environ.get("TEST_LIBVIRT_HOST"))
def ensure_pool(conn):
try:
pool = conn.storagePoolLookupByName(POOL)
except libvirt.libvirtError:
pool = conn.storagePoolDefineXML(
f"<pool type='dir'><name>{POOL}</name><target><path>{POOL_PATH}</path></target></pool>"
)
pool.build(0)
if not pool.isActive():
pool.create(0)
pool.refresh(0)
return pool
def cleanup(conn):
"""Remove prefixed domains and every volume of the test pool."""
for dom in conn.listAllDomains():
if not dom.name().startswith(PREFIX):
continue
persistent = dom.isPersistent()
if dom.isActive():
dom.destroy()
if persistent:
dom.undefineFlags(UNDEFINE_FLAGS)
try:
pool = conn.storagePoolLookupByName(POOL)
except libvirt.libvirtError:
return
if pool.isActive():
pool.refresh(0)
for vol in pool.listAllVolumes():
vol.delete(0)
def remove_pool(conn):
cleanup(conn)
try:
pool = conn.storagePoolLookupByName(POOL)
except libvirt.libvirtError:
return
if pool.isActive():
pool.destroy()
pool.delete(0)
pool.undefine()
def inventory(conn):
"""Domains and volumes outside the test namespace."""
domains = {(d.name(), d.UUIDString()) for d in conn.listAllDomains() if not d.name().startswith(PREFIX)}
volumes = set()
for pool in conn.listAllStoragePools():
if pool.name() == POOL or not pool.isActive():
continue
pool.refresh(0)
volumes.update((pool.name(), v.name()) for v in pool.listAllVolumes())
return domains, volumes
def create_volume(conn, name, size_mib=64):
"""A qcow2 volume in the test pool; returns its path."""
assert name.startswith(PREFIX)
pool = conn.storagePoolLookupByName(POOL)
vol = pool.createXML(
f"<volume><name>{name}.qcow2</name><capacity unit='MiB'>{size_mib}</capacity>"
"<target><format type='qcow2'/></target></volume>",
0,
)
return vol.path()
OVMF_CODE = "/usr/share/edk2/ovmf/OVMF_CODE.fd"
def define_vm(conn, name, disk_paths, uefi=False, extra_devices=""):
"""A small q35 VM without an OS; disks are attached as vda, vdb, ..."""
assert name.startswith(PREFIX)
disks = "".join(
f"<disk type='file' device='disk'><driver name='qemu' type='qcow2'/>"
f"<source file='{path}'/><target dev='vd{chr(ord('a') + i)}' bus='virtio'/></disk>"
for i, path in enumerate(disk_paths)
)
firmware = (
"<os><type arch='x86_64' machine='q35'>hvm</type>"
f"<loader readonly='yes' type='pflash'>{OVMF_CODE}</loader></os>"
if uefi
else "<os><type arch='x86_64' machine='q35'>hvm</type></os>"
)
return conn.defineXML(
f"<domain type='kvm'><name>{name}</name><memory unit='MiB'>128</memory><vcpu>1</vcpu>"
f"{firmware}<features><acpi/></features><devices>{disks}{extra_devices}</devices></domain>"
)
def volume_exists(conn, path):
pool = conn.storagePoolLookupByName(POOL)
pool.refresh(0)
return os.path.basename(path) in pool.listVolumes()

View file

@ -0,0 +1,57 @@
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
class ChangeNetworkViewTestCase(TestCase):
def setUp(self):
admin = get_user_model().objects.create_superuser("net_admin", "n@example.com", "pw")
self.client.force_login(admin)
compute = Compute.objects.create(name="net-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=compute, name="net-vm", uuid="11111111-2222-3333-4444-555555555555"
)
self.url = reverse("instances:change_network", args=[self.instance.id])
def post(self, data):
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_status.return_value = 5
self.client.post(self.url, data, HTTP_REFERER="/instances/%d/" % self.instance.id)
return wvm.return_value.change_network
def test_changes_the_nic_of_the_submitted_form(self):
change = self.post({
"net-old-mac-1": "52:54:00:00:00:02",
"net-mac-1": "52:54:00:00:00:03",
"net-source-1": "net:default",
"net-nwfilter-1": "",
"net-model-1": "e1000",
})
change.assert_called_once_with("52:54:00:00:00:02", "52:54:00:00:00:03", "default", "net", "e1000", "")
def test_invalid_mac_is_rejected(self):
change = self.post({
"net-old-mac-0": "52:54:00:00:00:01",
"net-mac-0": "52:54:00:00:00:01'/><evil/>",
"net-source-0": "net:default",
})
change.assert_not_called()
def test_missing_old_mac_is_rejected(self):
change = self.post({"net-mac-0": "52:54:00:00:00:03", "net-source-0": "net:default"})
change.assert_not_called()
def test_missing_referer_redirects_to_the_instance(self):
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_status.return_value = 5
response = self.client.post(self.url, {
"net-old-mac-0": "52:54:00:00:00:01",
"net-source-0": "net:default",
"net-model-0": "virtio",
})
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, f"/instances/{self.instance.id}/#network")

View file

@ -0,0 +1,32 @@
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
class ChangeXmlTestCase(TestCase):
def setUp(self):
self.client.force_login(get_user_model().objects.create_superuser("xml_admin", "x@example.com", "pw"))
compute = Compute.objects.create(name="xml-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(compute=compute, name="xml-vm", uuid="11111111-2222-3333-4444-888888888888")
def post(self, status):
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_status.return_value = status
response = self.client.post(reverse("instances:change_xml", args=[self.instance.id]), {"inst_xml": "<domain/>"})
return response, wvm.return_value._defineXML
def test_shut_off_vm_gets_the_new_definition(self):
_, define = self.post(status=5)
define.assert_called_once_with("<domain/>")
def test_running_or_paused_vm_is_refused(self):
for status in (1, 3):
with self.subTest(status=status):
response, define = self.post(status)
define.assert_not_called()
self.assertIn("Power off", " ".join(str(m) for m in get_messages(response.wsgi_request)))

View file

@ -0,0 +1,54 @@
"""A clone copies the disks of the VM's persistent definition: its quota and
disk names come from those, not from the running VM's disks."""
from unittest.mock import PropertyMock, patch
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from appsettings.models import AppSettings
from computes.models import Compute
from instances.models import Instance
LIVE = [{"dev": "vda", "path": "/pool/live.qcow2", "storage": "pool", "image": "live.qcow2", "size": 1 << 30}]
SAVED = [{"dev": "vdb", "path": "/pool/saved.qcow2", "storage": "pool", "image": "saved.qcow2", "size": 20 << 30}]
class CloneDisksTestCase(TestCase):
def setUp(self):
compute = Compute.objects.create(name="cd", hostname="192.0.2.5", login="root", password="", type=1)
self.vm = Instance.objects.create(compute=compute, name="cd-vm", uuid="12345678-aaaa-bbbb-cccc-1234567890ab")
def clone(self, user, **post):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
), patch("instances.views.utils.check_user_quota", return_value="") as quota:
wvm.return_value.get_disk_devices.side_effect = lambda config=False: SAVED if config else LIVE
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.get_memory.return_value = 512
wvm.return_value.get_net_devices.return_value = []
wvm.return_value.clone_instance.return_value = "abcdefab-0000-1111-2222-333333333333"
response = self.client.post(reverse("instances:clone", args=[self.vm.id]), post)
self.messages = [str(m) for m in response.wsgi_request._messages]
return quota, wvm.return_value.clone_instance
def test_the_quota_counts_the_disks_the_clone_copies(self):
owner = get_user_model().objects.create_user("cd_owner", password="x")
owner.user_permissions.add(Permission.objects.get(codename="clone_instances"))
UserInstance.objects.create(instance=self.vm, user=owner, is_change=True)
quota, _ = self.clone(owner, name="cd-clone")
self.assertEqual(quota.call_args.args[4], 20)
def test_automatic_disk_names_are_for_the_disks_the_clone_copies(self):
admin = get_user_model().objects.create_superuser("cd_admin", "cd@example.com", "x")
AppSettings.objects.filter(key="CLONE_INSTANCE_AUTO_NAME").update(value="True")
with patch("instances.views.utils.get_clone_free_names", return_value=["auto-1"]), patch(
"instances.views.utils.get_dhcp_mac_address", return_value="52:54:00:00:00:01"
):
_, clone_instance = self.clone(admin)
data = clone_instance.call_args.args[0]
self.assertIn("disk-vdb", data)
self.assertNotIn("disk-vda", data)

View file

@ -0,0 +1,235 @@
"""
Cloning another user's VM must require change permission on it (templates
excepted), and the clone data must not be taken blindly from the POST body.
"""
import tempfile
from contextlib import contextmanager
from pathlib import Path
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase, override_settings
from django.urls import reverse
from accounts.models import UserInstance
from appsettings.settings import app_settings
from computes.models import Compute
from instances.models import Instance
from instances.utils import get_dhcp_mac_address
SRC_DISK = {
"dev": "vda",
"image": "src-vm.qcow2",
"storage": "default",
"path": "/var/lib/libvirt/images/src-vm.qcow2",
"size": 10 << 30,
"format": "qcow2",
}
class ClonePermissionTestCase(TestCase):
def setUp(self):
User = get_user_model()
clone_perm = Permission.objects.get(codename="clone_instances")
view_perm = Permission.objects.get(codename="view_instances")
self.superuser = User.objects.create_superuser(
username="clone_super", email="clone_super@example.com", password="password"
)
self.viewer = User.objects.create_user(username="clone_viewer", password="password")
self.viewer.user_permissions.add(clone_perm, view_perm)
self.owner_readonly = User.objects.create_user(
username="clone_owner_ro", password="password"
)
self.owner_readonly.user_permissions.add(clone_perm)
self.owner_change = User.objects.create_user(
username="clone_owner_rw", password="password"
)
self.owner_change.user_permissions.add(clone_perm)
self.compute = Compute.objects.create(
name="clone-compute", hostname="127.0.0.1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="src-vm",
uuid="12121212-3434-5656-7878-909090909090",
)
UserInstance.objects.create(
instance=self.instance, user=self.owner_readonly, is_change=False
)
UserInstance.objects.create(
instance=self.instance, user=self.owner_change, is_change=True
)
@contextmanager
def mocked_libvirt(self):
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.utils.check_user_quota", return_value=""
):
proxy = mock_wvm.return_value
proxy.get_disk_devices.return_value = [SRC_DISK]
proxy.get_net_devices.return_value = [{"mac": "52:54:00:aa:bb:cc"}]
proxy.get_vcpu.return_value = 1
proxy.get_memory.return_value = 512
proxy.clone_instance.return_value = "abababab-cdcd-efef-0101-232323232323"
yield proxy
def _clone(self, user, data):
self.client.force_login(user)
return self.client.post(
reverse("instances:clone", args=[self.instance.id]),
data,
HTTP_REFERER=f"/instances/{self.instance.id}/",
)
def _valid_post(self, **extra):
data = {
"name": "clone-vm",
"clone-net-mac-0": "52:54:00:12:34:56",
"disk-vda": "clone-vm.qcow2",
"clone-title": "",
"clone-description": "",
}
data.update(extra)
return data
def test_viewer_cannot_clone_someone_elses_vm(self):
with self.mocked_libvirt() as proxy:
res = self._clone(self.viewer, self._valid_post())
self.assertEqual(res.status_code, 403)
proxy.clone_instance.assert_not_called()
def test_owner_without_is_change_cannot_clone(self):
with self.mocked_libvirt() as proxy:
res = self._clone(self.owner_readonly, self._valid_post())
self.assertEqual(res.status_code, 403)
proxy.clone_instance.assert_not_called()
def test_a_clone_stays_on_the_host_of_its_vm(self):
# the removed "VM Clone Auto Migrate" setting sent it to a random host
other = Compute.objects.create(name="other-host", hostname="198.51.100.20", login="", password="", type=4)
with self.mocked_libvirt() as proxy, \
patch("instances.views.utils.migrate_instance") as migrate, \
patch.object(app_settings, "CLONE_INSTANCE_AUTO_MIGRATE", "True", create=True), \
patch("instances.views.Compute.objects.order_by") as random_host:
random_host.return_value.first.return_value = other
self._clone(self.owner_change, self._valid_post())
proxy.clone_instance.assert_called_once()
migrate.assert_not_called()
self.assertEqual(Instance.objects.get(name="clone-vm").compute, self.instance.compute)
def test_viewer_can_clone_a_template(self):
self.instance.is_template = True
self.instance.save(update_fields=["is_template"])
with self.mocked_libvirt() as proxy:
self._clone(self.viewer, self._valid_post())
proxy.clone_instance.assert_called_once()
def test_posted_disk_owner_and_unknown_keys_are_ignored(self):
with self.mocked_libvirt() as proxy:
self._clone(
self.owner_change,
self._valid_post(disk_owner_uid="4242", disk_owner_gid="4242", evil="x"),
)
proxy.clone_instance.assert_called_once()
clone_data = proxy.clone_instance.call_args[0][0]
self.assertEqual(
clone_data["disk_owner_uid"],
int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_UID),
)
self.assertEqual(
clone_data["disk_owner_gid"],
int(app_settings.INSTANCE_VOLUME_DEFAULT_OWNER_GID),
)
self.assertNotIn("evil", clone_data)
def test_non_superuser_disk_names_are_derived_by_the_server(self):
with self.mocked_libvirt() as proxy:
self._clone(
self.owner_change,
self._valid_post(**{"disk-vda": "../../../etc/passwd"}),
)
proxy.clone_instance.assert_called_once()
clone_data = proxy.clone_instance.call_args[0][0]
self.assertEqual(clone_data["disk-vda"], "clone-vm.qcow2")
def test_superuser_unsafe_disk_name_is_rejected(self):
with self.mocked_libvirt() as proxy:
self._clone(
self.superuser,
self._valid_post(**{"disk-vda": "x</name><evil/>"}),
)
proxy.clone_instance.assert_not_called()
def test_superuser_invalid_second_mac_is_rejected(self):
with self.mocked_libvirt() as proxy:
self._clone(
self.superuser,
self._valid_post(**{"clone-net-mac-1": "not-a-mac"}),
)
proxy.clone_instance.assert_not_called()
def test_clone_holds_the_compute_exclusively(self):
# Clones of different VMs must not race for the destination name.
calls = []
@contextmanager
def record(compute, timeout=15.0, *, shared=False):
calls.append(shared)
yield
with self.mocked_libvirt() as proxy, patch("instances.views.libvirt_compute_lock", record):
self._clone(self.superuser, self._valid_post())
proxy.clone_instance.assert_called_once()
self.assertEqual(calls, [False])
def test_superuser_valid_clone_passes_posted_values(self):
with self.mocked_libvirt() as proxy:
self._clone(
self.superuser,
self._valid_post(**{"disk-vda": "custom-name.qcow2", "meta-vda": "true"}),
)
proxy.clone_instance.assert_called_once()
clone_data = proxy.clone_instance.call_args[0][0]
self.assertEqual(clone_data["disk-vda"], "custom-name.qcow2")
self.assertEqual(clone_data["meta-vda"], "true")
self.assertEqual(clone_data["clone-net-mac-0"], "52:54:00:12:34:56")
def test_non_superuser_clone_skips_disks_without_a_volume(self):
empty_disk = {"dev": "vdb", "image": None, "storage": None, "path": None,
"size": None, "format": None}
with self.mocked_libvirt() as proxy:
proxy.get_disk_devices.return_value = [SRC_DISK, empty_disk]
self._clone(self.owner_change, self._valid_post())
proxy.clone_instance.assert_called_once()
clone_data = proxy.clone_instance.call_args[0][0]
self.assertEqual(clone_data["disk-vda"], "clone-vm.qcow2")
self.assertIsNone(clone_data["disk-vdb"])
def test_derived_disk_names_are_sanitized_instead_of_rejected(self):
odd_disk = dict(SRC_DISK, image="my disk@2.qcow2")
with self.mocked_libvirt() as proxy:
proxy.get_disk_devices.return_value = [odd_disk]
self._clone(self.owner_change, self._valid_post())
proxy.clone_instance.assert_called_once()
self.assertEqual(
proxy.clone_instance.call_args[0][0]["disk-vda"], "my-disk-2-clone.qcow2"
)
class DhcpdConfTestCase(TestCase):
"""Clone name and MAC come from the same dhcpd.conf, next to the app."""
def test_guess_clone_name_and_mac_read_the_app_directory(self):
self.client.force_login(get_user_model().objects.create_superuser("dhcp_admin", "d@example.com", "pw"))
with tempfile.TemporaryDirectory() as tmp, override_settings(BASE_DIR=Path(tmp)):
Path(tmp, "dhcpd.conf").write_text(
"host clone7.example.com {\n hardware ethernet 52:54:00:00:07:07;\n}\n"
)
with patch("instances.views.app_settings") as app_settings:
app_settings.CLONE_INSTANCE_DEFAULT_PREFIX = "clone"
response = self.client.get(reverse("instances:guess_clone_name"))
self.assertEqual(response.json(), {"name": "clone7"})
self.assertEqual(get_dhcp_mac_address("clone7"), "52:54:00:00:07:07")

View file

@ -0,0 +1,98 @@
"""Only administrators choose where a VM's console listens. Other users who may
manage the console cannot make it listen beyond localhost, and cannot remove
the password of a console that does."""
from unittest.mock import PropertyMock, patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from vrtManager.instance import PERSISTENT_XML, wvmInstance
class ConsoleListenerTests(TestCase):
def setUp(self):
User = get_user_model()
self.owner = User.objects.create_user("console-owner", password="pw")
self.admin = User.objects.create_superuser("console-admin", password="pw", email="ca@example.com")
compute = Compute.objects.create(name="cl", hostname="10.0.0.1", login="u", password="p", type=1)
self.vm = Instance.objects.create(compute=compute, name="cl-vm", uuid="78787878-0000-0000-0000-000000000000")
UserInstance.objects.create(user=self.owner, instance=self.vm, is_change=True, is_vnc=True)
def post(self, user, data, local=True):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as wvm:
proxy = wvm.return_value
proxy.console_listens_locally.return_value = local
proxy.set_console_passwd.return_value = True
response = self.client.post(reverse("instances:update_console", args=[self.vm.id]), data)
return proxy, [str(m) for m in get_messages(response.wsgi_request)]
def test_owner_cannot_change_the_listen_address(self):
proxy, _ = self.post(self.owner, {"listen_on": "0.0.0.0", "keymap": "auto"})
proxy.set_console_listener_addr.assert_not_called()
def test_owner_cannot_remove_the_password_of_a_console_listening_beyond_localhost(self):
proxy, messages = self.post(self.owner, {"clear_password": "on", "keymap": "auto"}, local=False)
proxy.set_console_passwd.assert_not_called()
self.assertTrue(any("password" in m.lower() for m in messages), messages)
def test_owner_can_remove_the_password_of_a_local_console(self):
proxy, _ = self.post(self.owner, {"clear_password": "on", "keymap": "auto"})
proxy.set_console_passwd.assert_called_once_with("")
def test_owner_can_set_a_password_of_any_console(self):
proxy, _ = self.post(self.owner, {"password": "s3cret-pass", "keymap": "auto"}, local=False)
proxy.set_console_passwd.assert_called_once_with("s3cret-pass")
def test_superuser_can_open_the_console_to_all_interfaces(self):
proxy, _ = self.post(self.admin, {"listen_on": "0.0.0.0", "clear_password": "on", "keymap": "auto"}, local=False)
proxy.set_console_listener_addr.assert_called_once_with("0.0.0.0")
proxy.set_console_passwd.assert_called_once_with("")
def test_owner_sees_the_listen_address_but_cannot_edit_it(self):
self.client.force_login(self.owner)
with patch("instances.models.wvmInstance") as wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
):
proxy = wvm.return_value
proxy.get_memory.return_value = 1024
proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
proxy.get_console_listener_addr.return_value = "127.0.0.1"
for name in ("get_networks", "get_ifaces", "get_storages", "get_disk_devices", "get_media_devices", "get_net_devices"):
getattr(proxy, name).return_value = []
proxy.get_status.return_value = 5
response = self.client.get(reverse("instances:instance", args=[self.vm.id]))
form = response.context["console_form"]
self.assertTrue(form.fields["listen_on"].disabled)
class ConsoleListensLocallyTests(TestCase):
"""Only a binding the persistent XML pins to loopback (or a Unix socket) is local."""
def listens_locally(self, graphics):
proxy = wvmInstance.__new__(wvmInstance) # no connection: only the XML is read
xml = f"<domain><devices>{graphics}</devices></domain>"
proxy._XMLDesc = lambda flags: xml if flags == PERSISTENT_XML else "<wrong-flags/>"
return proxy.console_listens_locally()
def test_cases(self):
cases = {
"<graphics type='vnc' listen='127.0.0.1'><listen type='address' address='127.0.0.1'/></graphics>": True,
"<graphics type='vnc'><listen type='address' address='::1'/></graphics>": True,
"<graphics type='vnc'><listen type='socket' socket='/run/vnc.sock'/></graphics>": True,
"": True, # no console
"<graphics type='vnc' listen='0.0.0.0'><listen type='address' address='0.0.0.0'/></graphics>": False,
"<graphics type='vnc'><listen type='network' network='default'/></graphics>": False,
"<graphics type='vnc' autoport='yes'/>": False, # the host default decides
"<graphics type='vnc'><listen type='address' address='localhost'/></graphics>": False,
"<graphics type='vnc' listen='127.0.0.1'><listen type='address' address='10.0.0.5'/></graphics>": False,
}
for graphics, expected in cases.items():
with self.subTest(graphics=graphics):
self.assertIs(self.listens_locally(graphics), expected)

View file

@ -0,0 +1,78 @@
"""
One rule decides who may open a VM's console (noVNC page, novncd, the
virt-viewer .vv file, the VDI URL): a superuser or an owner of the VM. The
global view_instances permission is read-only.
"""
from unittest.mock import MagicMock, patch
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
from instances.utils import can_open_console
class CanOpenConsoleTestCase(TestCase):
def setUp(self):
User = get_user_model()
self.superuser = User.objects.create_superuser(
username="cons_super", email="cons_super@example.com", password="x"
)
self.owner = User.objects.create_user(username="cons_owner", password="x")
self.inactive_owner = User.objects.create_user(
username="cons_inactive", password="x", is_active=False
)
self.viewer = User.objects.create_user(username="cons_viewer", password="x")
self.viewer.user_permissions.add(Permission.objects.get(codename="view_instances"))
self.stranger = User.objects.create_user(username="cons_stranger", password="x")
self.compute = Compute.objects.create(
name="cons-compute", hostname="127.0.0.1:1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="cons-vm",
uuid="77777777-8888-9999-aaaa-bbbbbbbbbbbb",
)
UserInstance.objects.create(instance=self.instance, user=self.owner)
UserInstance.objects.create(instance=self.instance, user=self.inactive_owner)
def test_superuser_and_owner_may_open_console(self):
self.assertTrue(can_open_console(self.superuser, self.instance))
self.assertTrue(can_open_console(self.owner, self.instance))
def test_view_instances_stranger_and_inactive_owner_may_not(self):
self.assertFalse(can_open_console(self.viewer, self.instance))
self.assertFalse(can_open_console(self.stranger, self.instance))
self.assertFalse(can_open_console(self.inactive_owner, self.instance))
def test_owner_can_download_vv_file(self):
self.client.force_login(self.owner)
with patch("instances.models.wvmInstance") as wvm:
proxy = wvm.return_value.cached_reads.return_value.__enter__.return_value
proxy.instance.name.return_value = "cons-vm"
proxy.host = "192.0.2.7"
proxy.get_console_type.return_value = "vnc"
proxy.get_console_listener_addr.return_value = "0.0.0.0"
proxy.get_console_port.return_value = "5900"
proxy.get_console_passwd.return_value = "secret"
res = self.client.get(reverse("instances:getvvfile", args=[self.instance.id]))
self.assertEqual(res.status_code, 200)
self.assertIn(b"[virt-viewer]", res.content)
# the VM found by its UUID; a console on all addresses is reached through the host
for line in (b"type=vnc", b"host=192.0.2.7", b"port=5900", b"title=cons-vm", b"password=secret"):
self.assertIn(line + b"\n", res.content)
def test_owner_can_get_vdi_url(self):
self.client.force_login(self.owner)
with patch("datasource.views.wvmInstance", MagicMock()), patch(
"datasource.views.get_hostname_by_ip", return_value="host"
):
res = self.client.get(
reverse("vdi_url", args=[self.compute.id, self.instance.name])
)
self.assertEqual(res.status_code, 200)

View file

@ -0,0 +1,87 @@
"""
The console settings form on the VM detail page carries the VNC password
(PasswordInput(render_value=True)). It must only be rendered for users who may
change console settings, which is the rule update_console enforces: a
superuser, or an owner with both is_change and is_vnc. In particular, is_staff
and the global view_instances permission must not reveal the VNC password.
"""
from unittest.mock import PropertyMock, patch
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
VNC_PASSWORD = "s3cretVNCpass"
class ConsoleSettingsAccessTestCase(TestCase):
def setUp(self):
User = get_user_model()
view_perm = Permission.objects.get(codename="view_instances")
self.superuser = User.objects.create_superuser(
username="vncpw_super", email="vncpw_super@example.com", password="x"
)
self.staff_viewer = User.objects.create_user(
username="vncpw_staff_viewer", password="x", is_staff=True
)
self.staff_viewer.user_permissions.add(view_perm)
self.staff_owner = User.objects.create_user(
username="vncpw_staff_owner", password="x", is_staff=True
)
self.vnc_owner = User.objects.create_user(username="vncpw_vnc_owner", password="x")
self.compute = Compute.objects.create(
name="vncpw-compute", hostname="127.0.0.1:1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="vncpw-vm",
uuid="cccccccc-dddd-eeee-ffff-000000000000",
)
UserInstance.objects.create(
instance=self.instance, user=self.staff_owner, is_change=True, is_vnc=False
)
UserInstance.objects.create(
instance=self.instance, user=self.vnc_owner, is_change=True, is_vnc=True
)
def _detail_page(self, user):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as mock_wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
):
proxy = mock_wvm.return_value
proxy.get_memory.return_value = 1024
proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
proxy.get_networks.return_value = []
proxy.get_ifaces.return_value = []
proxy.get_storages.return_value = []
proxy.get_console_passwd.return_value = VNC_PASSWORD
proxy.get_console_type.return_value = "vnc"
proxy.get_status.return_value = 5
proxy.get_disk_devices.return_value = []
proxy.get_media_devices.return_value = []
proxy.get_net_devices.return_value = []
response = self.client.get(
reverse("instances:instance", args=[self.instance.id])
)
self.assertEqual(response.status_code, 200)
return response.content.decode()
def test_staff_with_view_instances_does_not_see_vnc_password(self):
self.assertFalse(VNC_PASSWORD in self._detail_page(self.staff_viewer), "VNC password leaked")
def test_staff_owner_without_is_vnc_does_not_see_vnc_password(self):
self.assertFalse(VNC_PASSWORD in self._detail_page(self.staff_owner), "VNC password leaked")
def test_owner_with_is_change_and_is_vnc_sees_console_settings(self):
self.assertTrue(VNC_PASSWORD in self._detail_page(self.vnc_owner), "console settings missing")
def test_superuser_sees_console_settings(self):
self.assertTrue(VNC_PASSWORD in self._detail_page(self.superuser), "console settings missing")

View file

@ -0,0 +1,114 @@
"""The new-VM dialog's CPU bars: the page carries each compute's statistics
URL and reads no CPU usage itself; its script fills the bars when the dialog
opens, two computes at a time, and ignores answers of an earlier opening."""
import json
import shutil
import subprocess
import unittest
from unittest.mock import PropertyMock, patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from lxml import html
RUN = """
const vm = require("vm");
function element() {
const attrs = {};
return {style: {}, textContent: "", attrs,
setAttribute: (k, v) => { attrs[k] = String(v); }, removeAttribute: (k) => { delete attrs[k]; }};
}
const cells = URLS.map((url) => {
const bar = element(), label = element();
return {dataset: {url}, bar, label,
querySelector: (sel) => (sel === ".progress-bar" ? bar : label)};
});
const handlers = {}, requests = [];
const dialog = {addEventListener: (name, fn) => { handlers[name] = fn; }, querySelectorAll: () => cells};
const page = {
document: {getElementById: () => dialog},
$: {getJSON: (url) => {
const r = {url, done: (f) => { r.ok = f; return r; }, fail: (f) => { r.err = f; return r; },
always: (f) => { r.end = f; return r; }};
requests.push(r);
return r;
}},
window: {location: {}},
};
vm.runInNewContext(SCRIPT, vm.createContext(page));
const state = () => cells.map((c) => [c.bar.style.width, c.bar.attrs["aria-valuenow"] || null, c.label.textContent]);
const answer = (i, data) => { const r = requests[i]; data === null ? r.err() : r.ok(data); r.end(); };
const out = {};
handlers["show.bs.modal"]();
out.loading = state();
out.first = requests.map((r) => r.url);
handlers["hide.bs.modal"]();
answer(0, {cpudata: 5});
answer(1, null);
out.hidden = [state(), requests.length];
handlers["show.bs.modal"]();
answer(2, {cpudata: 0});
answer(3, {cpudata: null});
out.filled = state();
handlers["hide.bs.modal"]();
handlers["show.bs.modal"]();
out.reopened = requests.length;
answer(4, {cpudata: 99});
answer(5, {cpudata: 41.6});
answer(6, null);
out.final = state();
out.all = requests.map((r) => r.url);
console.log(JSON.stringify(out));
"""
class CreateDialogCpuTestCase(TestCase):
def setUp(self):
self.client.force_login(get_user_model().objects.create_superuser("cd-admin", "cd@example.com", "pw"))
self.computes = [
Compute.objects.create(name=f"cd{i}", hostname=f"192.0.2.{i}", login="u", password="p", type=1)
for i in (1, 2, 3)
]
patches = [
patch.object(Compute, name, new_callable=PropertyMock, return_value=value)
for name, value in (("status", True), ("cpu_count", 1), ("ram_size", 1024), ("ram_usage", 0))
]
patches += [patch("instances.views.utils.refr"), patch("computes.models.wvmHostDetails")]
for p in patches:
self.details = p.start() # the last one: the host connection
self.addCleanup(p.stop)
def page(self):
response = self.client.get(reverse("instances:index"))
self.assertEqual(response.status_code, 200)
return response.content.decode()
def test_the_page_carries_the_statistics_urls_and_reads_no_cpu_usage(self):
page = self.page()
urls = html.fromstring(page).xpath("//td[@class='cpu-usage']/@data-url")
self.assertEqual(urls, [reverse("compute_graph", args=[c.id]) for c in self.computes])
self.details.return_value.get_cpu_usage.assert_not_called()
@unittest.skipUnless(shutil.which("node"), "node is not installed")
def test_the_dialog_fills_the_bars_two_at_a_time(self):
page = self.page()
script = next(s for s in html.fromstring(page).xpath("//script[not(@src)]/text()") if "show.bs.modal" in s)
urls = [reverse("compute_graph", args=[c.id]) for c in self.computes]
js = RUN.replace("SCRIPT", json.dumps(script)).replace("URLS", json.dumps(urls))
out = subprocess.run(["node", "-e", js], capture_output=True, text=True, timeout=30)
self.assertEqual(out.returncode, 0, out.stderr)
result = json.loads(out.stdout)
self.assertEqual(result["loading"], [["0%", None, "…"]] * 3)
self.assertEqual(result["first"], urls[:2])
# answers that come after the dialog closed change nothing and read no more
self.assertEqual(result["hidden"], [[["0%", None, "…"]] * 3, 2])
# 0 is a value, no value is a dash
self.assertEqual(result["filled"], [["0%", "0", "0%"], ["0%", None, "—"], ["0%", None, "…"]])
# reopened while the third read runs: one more read, two in all
self.assertEqual(result["reopened"], 6)
# the earlier opening's answer (99) is ignored; a failed read is a dash
self.assertEqual(result["final"], [["42%", "42", "42%"], ["0%", None, "—"], ["0%", None, "…"]])
self.assertEqual(result["all"], urls[:2] + urls + urls)

View file

@ -0,0 +1,146 @@
"""Regression tests for the instance creation request."""
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.api.serializers import CreateInstanceSerializer
from instances.models import Instance
from instances.utils import nic_macs
class CreateInstanceViewTests(TestCase):
@patch("instances.views.wvmCreate")
@patch("instances.views.NewVMForm")
def test_successful_create_redirects_after_saving_instance(self, form_class, connection_class):
response, conn = self.create(form_class, connection_class)
instance = Instance.objects.get(name="new-vm")
self.assertRedirects(
response, reverse("instances:instance", args=[instance.id]),
fetch_redirect_response=False,
)
conn.create_instance.assert_called_once()
@patch("instances.views.wvmCreate")
@patch("instances.views.NewVMForm")
def test_secure_boot_loader_on_q35_requests_secure_boot(self, form_class, connection_class):
self.create(form_class, connection_class, firmware="UEFI x86_64: /usr/share/edk2/ovmf/OVMF_CODE.secboot.fd")
firmware = connection_class.return_value.create_instance.call_args.kwargs["firmware"]
self.assertEqual(firmware["secure"], "yes")
@patch("instances.views.wvmCreate")
@patch("instances.views.NewVMForm")
def test_invalid_devices_are_refused_before_anything_is_created(self, form_class, connection_class):
for data in (
{"add_cdrom": "virtio"}, # no ejectable media
{"add_cdrom": "fdc"},
{"add_cdrom": "usb"}, # libvirt refuses an empty usb disk
{"mac": "52:54:00:00:00:01,52:54:00:00:00:02"}, # one network
{"mac": "52:54:00:00:00:01'/><evil/>"},
):
with self.subTest(data):
Instance.objects.all().delete()
response, conn = self.create(form_class, connection_class, **data)
self.assertEqual(response.status_code, 200)
self.assertFalse(Instance.objects.exists())
conn.create_volume.assert_not_called()
conn.create_instance.assert_not_called()
connection_class.reset_mock()
def create(self, form_class, connection_class, **data):
user = get_user_model().objects.filter(username="create-test-admin").first() or (
get_user_model().objects.create_superuser(
username="create-test-admin", password="password", email="create@example.com"
)
)
self.client.force_login(user)
compute, _ = Compute.objects.get_or_create(
name="create-test-compute", hostname="localhost", type=4,
login="", password="",
)
conn = connection_class.return_value
conn.get_instances.return_value = []
conn.get_video_models.return_value = ["vga"]
conn.get_cache_modes.return_value = {"default": "Default"}
conn.get_disk_device_types.return_value = ["disk"]
conn.get_disk_bus_types.return_value = ["fdc", "virtio", "sata"]
conn.get_networks.return_value = ["default"]
conn.get_nwfilters.return_value = []
conn.get_network_models.return_value = ["virtio"]
conn.get_storages.return_value = ["default"]
conn.get_dom_capabilities.return_value = {"loader_enums": [], "loaders": []}
conn.get_capabilities.return_value = {}
conn.label_for_firmware_path.return_value = None
conn.find_uefi_path_for_arch.return_value = None
conn.get_volume_path.return_value = "/var/lib/libvirt/images/base.qcow2"
conn.get_volume_format_type.return_value = "qcow2"
form = form_class.return_value
form.is_valid.return_value = True
form.cleaned_data = {
"name": "new-vm", "meta_prealloc": False, "hdd_size": 0,
"template": "", "images": "base.qcow2", "cache_mode": "default",
"firmware": "BIOS", "net_model": "virtio", "memory": 1024,
"vcpu": 1, "vcpu_mode": "host-model", "networks": "default",
"virtio": True, "listener_addr": "0.0.0.0", "nwfilter": "",
"graphics": "vnc", "video": "vga", "console_pass": "",
"mac": "52:54:00:00:00:01", "qemu_ga": False,
"add_cdrom": "sata", "add_input": "default",
**data,
}
response = self.client.post(
reverse("instances:create_instance", args=[compute.id, "x86_64", "q35"]),
{"create": "1"},
)
return response, conn
@patch("instances.views.wvmCreate")
def test_firmware_list_uses_the_chosen_machine_type(self, connection_class):
user = get_user_model().objects.create_superuser(
username="create-fw-admin", password="password", email="fw@example.com"
)
self.client.force_login(user)
compute = Compute.objects.create(
name="create-fw-compute", hostname="localhost", type=4, login="", password="",
)
conn = connection_class.return_value
conn.get_instances.return_value = []
conn.get_storages.return_value = []
conn.get_networks.return_value = []
conn.get_nwfilters.return_value = []
conn.get_cache_modes.return_value = {}
# A host without loader support has no "loaders"/"loader_enums" keys
conn.get_dom_capabilities.return_value = {"loader_support": "no"}
conn.get_capabilities.return_value = {}
conn.label_for_firmware_path.return_value = None
conn.find_uefi_path_for_arch.return_value = None
response = self.client.get(reverse("instances:create_instance", args=[compute.id, "x86_64", "q35"]))
self.assertEqual(response.status_code, 200)
conn.find_uefi_path_for_arch.assert_called_once_with("x86_64", "q35")
class NicMacsTestCase(TestCase):
def test_macs_follow_the_networks(self):
self.assertEqual(nic_macs("52:54:00:00:00:01", "a,b"), ["52:54:00:00:00:01"])
self.assertEqual(nic_macs("", "a,b"), [])
def test_invalid_or_extra_macs_are_refused(self):
for mac, networks in (("52:54:00:00:00:01,52:54:00:00:00:02", "a"), ("not-a-mac", "a")):
with self.subTest(mac=mac), self.assertRaises(ValueError):
nic_macs(mac, networks)
def test_api_serializer_refuses_extra_macs(self):
serializer = CreateInstanceSerializer(data={
"name": "api-vm", "vcpu": 1, "vcpu_mode": "host-model", "memory": 512,
"networks": "default", "mac": "52:54:00:00:00:01,52:54:00:00:00:02", "nwfilter": "",
"storage": "default", "hdd_size": 1, "cache_mode": "none", "meta_prealloc": False,
"virtio": True, "qemu_ga": True, "console_pass": "", "video": "vga", "listener_addr": "0.0.0.0",
})
self.assertFalse(serializer.is_valid())
self.assertIn("mac", serializer.errors)

View file

@ -0,0 +1,48 @@
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from libvirt import libvirtError
FORM = {
"name": "rb-vm", "firmware": "BIOS", "vcpu": 1, "vcpu_mode": "host-model", "memory": 128,
"hdd_size": 1, "storage": "default", "mac": "52:54:00:aa:04:01", "networks": "default",
"nwfilter": "", "net_model": "virtio", "cache_mode": "none", "video": "vga",
"listener_addr": "0.0.0.0", "console_pass": "", "add_cdrom": "None", "add_input": "None",
"create": True,
}
class CreateRollbackTestCase(TestCase):
"""Volumes are removed only while the VM is not defined yet."""
def setUp(self):
admin = get_user_model().objects.create_superuser("rb_admin", "r@example.com", "pw")
self.client.force_login(admin)
self.client.raise_request_exception = False
self.compute = Compute.objects.create(name="rb", hostname="127.0.0.1", login="", password="", type=4)
def post(self, **conn_setup):
with patch("instances.views.wvmCreate") as wvm:
conn = wvm.return_value
conn.get_cache_modes.return_value = {"none": "Disable cache"}
conn.get_instances.return_value = []
conn.get_storages.return_value = ["default"]
conn.get_networks.return_value = ["default"]
conn.create_volume.return_value = "/pool/rb-vm.qcow2"
for attr, value in conn_setup.items():
getattr(conn, attr).side_effect = value
self.client.post(reverse("instances:create_instance", args=[self.compute.id, "x86_64", "q35"]), FORM)
return conn
def test_failed_definition_removes_the_new_volume(self):
conn = self.post(create_instance=libvirtError("rejected"))
conn.delete_volume.assert_called_once_with("/pool/rb-vm.qcow2")
def test_failure_after_the_definition_keeps_the_volume(self):
with patch("instances.views.Instance.objects.get_or_create", side_effect=RuntimeError("db down")):
conn = self.post()
conn.create_instance.assert_called_once()
conn.delete_volume.assert_not_called()

View file

@ -0,0 +1,36 @@
"""The create wizard's first page sends the browser to the next page for the
chosen architecture and machine type; the URL is built from placeholders."""
import re
import subprocess
import shutil
import unittest
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.template.loader import render_to_string
from django.test import RequestFactory, TestCase
class CreateWizardUrlTests(TestCase):
def render_script(self):
compute = Compute.objects.create(name="cw", hostname="10.0.0.6", login="u", password="p", type=1)
request = RequestFactory().get("/")
request.user = get_user_model().objects.create_superuser("cw-admin", "cw@example.com", "pw")
page = render_to_string("create_instance_w1.html", {"compute": compute}, request=request)
# the statement that builds the URL from arch and machine
return re.search(r"\burl = (.*?);", page, re.S).group(1)
@unittest.skipUnless(shutil.which("node"), "node is not installed")
def test_arch_and_machine_names_land_in_their_segments(self):
script = self.render_script()
cases = {
("x86_64", "q35"): "x86_64/q35/",
("ppc64le", "pseries"): "ppc64le/pseries/", # contains "pc"
("aarch64", "virt"): "aarch64/virt/",
}
for (arch, machine), tail in cases.items():
js = "const arch = %r, machine = %r; console.log(%s);" % (arch, machine, script)
out = subprocess.run(["node", "-e", js], capture_output=True, text=True, timeout=30)
with self.subTest(arch=arch):
self.assertTrue(out.stdout.strip().endswith(f"/{tail}"), out.stdout + out.stderr)

View file

@ -0,0 +1,87 @@
from contextlib import contextmanager
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from libvirt import VIR_DOMAIN_UNDEFINE_KEEP_NVRAM, VIR_DOMAIN_UNDEFINE_NVRAM, libvirtError
class DestroyOrderTestCase(TestCase):
def setUp(self):
admin = get_user_model().objects.create_superuser("destroy_admin", "d@example.com", "pw")
self.client.force_login(admin)
self.client.raise_request_exception = False
compute = Compute.objects.create(name="destroy-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=compute, name="destroy-vm", uuid="11111111-2222-3333-4444-555555555555"
)
def destroy(self, undefine_error=None, data=None):
with patch("instances.models.wvmInstance") as wvm:
proxy = wvm.return_value
proxy.instance.isActive.return_value = False
proxy.split_disk_paths_by_use.return_value = (["/pool/own.qcow2"], ["/pool/shared.qcow2"])
proxy.delete.side_effect = undefine_error
self.client.post(reverse("instances:destroy", args=[self.instance.id]), data or {"delete_disk": "1"})
return proxy
def test_the_nvram_goes_only_when_asked(self):
for data, wanted, unwanted in (
({"delete_nvram": "1"}, VIR_DOMAIN_UNDEFINE_NVRAM, VIR_DOMAIN_UNDEFINE_KEEP_NVRAM),
({}, VIR_DOMAIN_UNDEFINE_KEEP_NVRAM, VIR_DOMAIN_UNDEFINE_NVRAM),
):
with self.subTest(data=data):
Instance.objects.get_or_create(
compute=self.instance.compute, name="destroy-vm", uuid="11111111-2222-3333-4444-555555555555"
)
self.instance = Instance.objects.get(uuid="11111111-2222-3333-4444-555555555555")
flags = self.destroy(data=data).delete.call_args[0][0]
self.assertTrue(flags & wanted)
self.assertFalse(flags & unwanted)
def test_disks_are_deleted_after_the_undefine(self):
proxy = self.destroy()
proxy.get_volume_by_path.assert_called_once_with("/pool/own.qcow2")
self.assertFalse(Instance.objects.filter(pk=self.instance.pk).exists())
def test_failed_undefine_deletes_no_disk(self):
proxy = self.destroy(undefine_error=libvirtError("refused"))
proxy.get_volume_by_path.assert_not_called()
proxy.delete_all_disks.assert_not_called()
self.assertTrue(Instance.objects.filter(pk=self.instance.pk).exists())
def test_destroy_and_delete_vol_hold_the_compute_exclusively(self):
calls = []
@contextmanager
def record(compute, timeout=15.0, *, shared=False):
calls.append(shared)
yield
with patch("instances.views.libvirt_compute_lock", record):
with patch("instances.models.wvmInstance"):
self.client.post(reverse("instances:delete_vol", args=[self.instance.id]), {"dev": "vda"})
self.destroy()
self.assertEqual(calls, [False, False])
def test_confirmation_page_takes_no_lock(self):
calls = []
@contextmanager
def record(compute, timeout=15.0, *, shared=False):
calls.append(shared)
yield
with patch("instances.views.libvirt_compute_lock", record), patch("instances.models.wvmInstance"):
response = self.client.get(reverse("instances:destroy", args=[self.instance.id]))
self.assertEqual(response.status_code, 200)
self.assertEqual(calls, [])
def test_the_confirmation_page_of_a_paused_vm_offers_the_form(self):
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_status.return_value = 3 # paused
response = self.client.get(reverse("instances:destroy", args=[self.instance.id]))
self.assertIn('id="delete_form"', response.content.decode())

View file

@ -0,0 +1,109 @@
"""The VM page reads each kind of domain XML, the VM's state, the host's
capabilities and info, and each disk's volume once, through the real getters,
on libvirt's test driver."""
from unittest.mock import patch
import libvirt
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
# a VM with a disk and a VNC console, on libvirt's test driver
DOMAIN = """<domain type='test'><name>read-cache-vm</name><uuid>0b9f6a52-6d0e-4c1f-9a51-2f3c1d7e8a40</uuid><memory unit='MiB'>128</memory><vcpu>1</vcpu>
<os><type arch='i686'>hvm</type></os>
<devices><disk type='file' device='disk'><source file='/default-pool/read-cache.img'/><target dev='vda' bus='virtio'/></disk>
<graphics type='vnc' port='-1' listen='127.0.0.1'><listen type='address' address='127.0.0.1'/></graphics></devices>
</domain>"""
class DetailReadsTests(TestCase):
def setUp(self):
self.conn = libvirt.open("test:///default")
self.addCleanup(self.conn.close)
# the test host lives on while a libvirt object still refers to it
pool = self.conn.storagePoolLookupByName("default-pool")
if "read-cache.img" not in pool.listVolumes():
pool.createXML("<volume><name>read-cache.img</name><capacity>1048576</capacity></volume>", 0)
domain = self.conn.defineXML(DOMAIN)
self.compute = Compute.objects.create(name="testdrv", hostname="localhost", login="", password="", type=4)
self.vm = Instance.objects.create(compute=self.compute, name=domain.name(), uuid=domain.UUIDString())
# what the test driver lacks: machine types, network filters
for target, value in (("get_machine_types", ["pc"]), ("get_nwfilters", [])):
patcher = patch(f"vrtManager.connection.wvmConnect.{target}", return_value=value)
patcher.start()
self.addCleanup(patcher.stop)
self.admin = get_user_model().objects.create_superuser("dr-admin", "dr@example.com", "pw")
def render(self):
xml_reads, cap_reads = [], []
real_xml, real_caps = libvirt.virDomain.XMLDesc, libvirt.virConnect.getCapabilities
def xml(dom, flags=0):
xml_reads.append(flags)
return real_xml(dom, flags)
def caps(conn):
cap_reads.append(1)
return real_caps(conn)
self.client.force_login(self.admin)
with patch("vrtManager.connection.connection_manager.get_connection", return_value=self.conn), patch.object(
libvirt.virDomain, "XMLDesc", xml
), patch.object(libvirt.virConnect, "getCapabilities", caps):
response = self.client.get(reverse("instances:instance", args=[self.vm.id]))
self.assertEqual(response.status_code, 200)
return response, xml_reads, cap_reads
def test_each_xml_and_the_capabilities_are_read_once(self):
_, xml_reads, cap_reads = self.render()
self.assertEqual(sorted(xml_reads), sorted(set(xml_reads)), "an XML read twice")
self.assertEqual(len(cap_reads), 1)
def test_the_state_host_info_and_disk_volume_are_read_once(self):
counted = (
(libvirt.virDomain, "info"),
(libvirt.virConnect, "getInfo"),
(libvirt.virConnect, "getDomainCapabilities"),
(libvirt.virConnect, "storageVolLookupByPath"),
(libvirt.virStorageVol, "info"),
)
calls = {}
def counter(cls, name):
real = getattr(cls, name)
def call(*args, **kwargs):
key = f"{cls.__name__}.{name}"
calls[key] = calls.get(key, 0) + 1
return real(*args, **kwargs)
return call
patches = [patch.object(cls, name, counter(cls, name)) for cls, name in counted]
for p in patches:
p.start()
self.addCleanup(p.stop)
response, _, _ = self.render()
self.assertContains(response, "read-cache.img")
self.assertEqual(
calls,
{
"virDomain.info": 1,
"virConnect.getInfo": 1,
"virConnect.getDomainCapabilities": 1,
"virConnect.storageVolLookupByPath": 1,
"virStorageVol.info": 1,
},
)
def test_a_change_after_the_page_reads_fresh_xml(self):
# outside the page the getters read libvirt each time, as changes need
with patch("vrtManager.connection.connection_manager.get_connection", return_value=self.conn):
proxy = self.vm.proxy
proxy.set_console_passwd("pass1")
proxy.set_console_keymap("de")
self.assertEqual(proxy.get_console_passwd(), "pass1")
self.assertEqual(proxy.get_console_keymap(), "de")

View file

@ -0,0 +1,45 @@
"""The page of a VM whose host cannot be reached sends the user to the list
with a message, instead of the error page with libvirt's connection error."""
from unittest.mock import PropertyMock, patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
ERROR = "Connection Failed: ssh: connect to host 10.0.0.9 port 22: No route to host"
class DetailOfUnreachableHostTests(TestCase):
def setUp(self):
self.compute = Compute.objects.create(name="far-host", hostname="10.0.0.9", login="root", password="", type=2)
self.vm = Instance.objects.create(compute=self.compute, name="far-vm", uuid="56565656-0000-0000-0000-000000000000")
self.owner = get_user_model().objects.create_user("far-owner", password="pw")
UserInstance.objects.create(user=self.owner, instance=self.vm)
def get(self, user):
self.client.force_login(user)
with patch.object(Compute, "status", new_callable=PropertyMock, return_value=False), patch.object(
Compute, "connection_error", new_callable=PropertyMock, return_value=ERROR
), patch("instances.models.wvmInstance", side_effect=AssertionError("VM read on a down host")):
response = self.client.get(reverse("instances:instance", args=[self.vm.id]))
self.assertRedirects(response, reverse("instances:index"), fetch_redirect_response=False)
return [str(m) for m in get_messages(response.wsgi_request)]
def test_owner_is_told_without_host_details(self):
messages = self.get(self.owner)
self.assertEqual(len(messages), 1)
self.assertIn("far-vm", messages[0])
self.assertNotIn("far-host", messages[0])
self.assertNotIn("10.0.0.9", messages[0])
def test_superuser_sees_the_host_and_its_error(self):
admin = get_user_model().objects.create_superuser("far-admin", password="pw", email="far@example.com")
messages = self.get(admin)
self.assertEqual(len(messages), 1)
self.assertIn("far-host", messages[0])
self.assertIn(ERROR, messages[0])

View file

@ -0,0 +1,358 @@
"""
Disk and media mutation views must be superuser-only (matching the UI, where
the Disk tab is only rendered for superusers), and even for superusers the
views must not act on volumes or option values taken blindly from the client.
"""
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
DISK_ENDPOINTS = [
("add_new_vol", []),
("add_existing_vol", []),
("edit_volume", []),
("delete_vol", []),
("detach_vol", []),
("add_cdrom", []),
("detach_cdrom", ["hda"]),
("mount_iso", []),
("unmount_iso", []),
]
VM_DISK = {
"dev": "vda",
"bus": "virtio",
"image": "vm-disk.qcow2",
"storage": "default",
"path": "/var/lib/libvirt/images/vm-disk.qcow2",
"format": "qcow2",
}
class DiskViewsTenantIsolationTestCase(TestCase):
def setUp(self):
User = get_user_model()
self.superuser = User.objects.create_superuser(
username="disk_super", email="disk_super@example.com", password="password"
)
self.change_user = User.objects.create_user(
username="disk_change_user", password="password"
)
self.staff_change_user = User.objects.create_user(
username="disk_staff_change_user", password="password", is_staff=True
)
self.compute = Compute.objects.create(
name="disk-compute", hostname="127.0.0.1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="disk-test-vm",
uuid="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
)
for user in (self.change_user, self.staff_change_user):
UserInstance.objects.create(
instance=self.instance, user=user, is_change=True, is_delete=False
)
self.referer = f"/instances/{self.instance.id}/"
def _url(self, name, extra=()):
return reverse(f"instances:{name}", args=[self.instance.id, *extra])
def _post(self, name, data, extra=()):
return self.client.post(self._url(name, extra), data, HTTP_REFERER=self.referer)
def test_owner_with_is_change_cannot_mutate_disks(self):
for user in (self.change_user, self.staff_change_user):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmStorage"
) as mock_storage, patch("instances.views.wvmCreate") as mock_create:
for name, extra in DISK_ENDPOINTS:
res = self._post(
name,
{"storage": "default", "name": "victim.qcow2", "dev": "vda"},
extra,
)
self.assertEqual(
res.status_code, 403, f"{user.username} POST {name} should be 403"
)
mock_wvm.assert_not_called()
mock_storage.assert_not_called()
mock_create.assert_not_called()
def test_delete_vol_deletes_the_volume_attached_to_dev_not_the_posted_one(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmStorage"
) as mock_storage:
mock_wvm.return_value.get_disk_devices.return_value = [VM_DISK]
res = self._post(
"delete_vol",
{"storage": "other-pool", "name": "victim.qcow2", "dev": "vda"},
)
self.assertEqual(res.status_code, 302)
mock_wvm.return_value.detach_disk.assert_called_once_with("vda")
self.assertEqual(mock_storage.call_args[0][-1], "default")
mock_storage.return_value.del_volume.assert_called_once_with("vm-disk.qcow2")
def test_delete_vol_refuses_dev_not_attached_to_vm(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmStorage"
) as mock_storage:
mock_wvm.return_value.get_disk_devices.return_value = [VM_DISK]
res = self._post(
"delete_vol",
{"storage": "default", "name": "victim.qcow2", "dev": "vdz"},
)
self.assertEqual(res.status_code, 302)
mock_wvm.return_value.detach_disk.assert_not_called()
mock_storage.return_value.del_volume.assert_not_called()
def test_edit_volume_rejects_unknown_cache_mode(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm:
proxy = mock_wvm.return_value
proxy.get_disk_devices.return_value = [VM_DISK]
proxy.get_media_devices.return_value = []
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
proxy.get_io_modes.return_value = {"default": "", "native": ""}
proxy.get_discard_modes.return_value = {"default": "", "unmap": ""}
proxy.get_detect_zeroes_modes.return_value = {"default": "", "on": ""}
res = self._post(
"edit_volume",
{
"edit_volume": "1",
"dev": "vda",
"vol_path": VM_DISK["path"],
"vol_bus_old": "virtio",
"vol_bus": "virtio",
"vol_format": "qcow2",
"vol_cache": "none' io='native",
},
)
self.assertEqual(res.status_code, 302)
proxy.edit_disk.assert_not_called()
proxy.attach_disk.assert_not_called()
proxy.detach_disk.assert_not_called()
def test_add_new_vol_rejects_unknown_bus(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmCreate"
) as mock_create, patch("instances.views.wvmStorage"):
proxy = mock_wvm.return_value
proxy.get_disk_devices.return_value = [VM_DISK]
proxy.get_media_devices.return_value = []
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
res = self._post(
"add_new_vol",
{
"storage": "default",
"name": "new-disk",
"format": "qcow2",
"size": "10",
"bus": "virtio'/><disk",
"cache": "default",
},
)
self.assertEqual(res.status_code, 302)
mock_create.return_value.create_volume.assert_not_called()
proxy.attach_disk.assert_not_called()
def test_add_existing_vol_rejects_volume_not_in_pool(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmStorage"
) as mock_storage:
proxy = mock_wvm.return_value
proxy.get_disk_devices.return_value = [VM_DISK]
proxy.get_media_devices.return_value = []
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
mock_storage.return_value.get_volumes.return_value = ["vm-disk.qcow2"]
res = self._post(
"add_existing_vol",
{
"selected_storage": "default",
"vols": "../../../etc/shadow",
"bus": "virtio",
"cache": "default",
},
)
self.assertEqual(res.status_code, 302)
proxy.attach_disk.assert_not_called()
def test_add_existing_vol_attaches_the_volume_by_its_own_path(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmStorage"
) as mock_storage:
proxy = mock_wvm.return_value
proxy.get_disk_devices.return_value = [VM_DISK]
proxy.get_media_devices.return_value = []
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
pool = mock_storage.return_value
pool.get_volumes.return_value = ["unit:0:0:1"]
pool.get_type.return_value = "iscsi"
pool.get_volume_type.return_value = "block"
pool.get_volume_format_type.return_value = None # an iSCSI pool knows no format
pool.get_target_path.return_value = "/dev/disk/by-path"
pool.get_volume.return_value.path.return_value = "/dev/disk/by-path/ip-192.0.2.1:3260-iscsi-iqn.example-lun-1"
res = self._post(
"add_existing_vol",
{"selected_storage": "iscsi", "vols": "unit:0:0:1", "bus": "virtio", "cache": "default"},
)
self.assertEqual(res.status_code, 302)
pool.get_volume.assert_called_once_with("unit:0:0:1")
self.assertEqual(
proxy.attach_disk.call_args.args[1], "/dev/disk/by-path/ip-192.0.2.1:3260-iscsi-iqn.example-lun-1"
)
self.assertEqual(proxy.attach_disk.call_args.kwargs["format_type"], "raw")
def _mock_disk_options(self, proxy):
proxy.get_disk_devices.return_value = [VM_DISK]
proxy.get_media_devices.return_value = []
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
proxy.get_io_modes.return_value = {"default": "", "native": ""}
proxy.get_discard_modes.return_value = {"default": "", "unmap": ""}
proxy.get_detect_zeroes_modes.return_value = {"default": "", "on": ""}
def test_add_new_vol_rejects_unsafe_volume_name(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmCreate"
) as mock_create, patch("instances.views.wvmStorage"):
self._mock_disk_options(mock_wvm.return_value)
res = self._post(
"add_new_vol",
{
"storage": "default",
"name": "x</name><key>/etc/shadow",
"format": "qcow2",
"size": "10",
"bus": "virtio",
"cache": "default",
},
)
self.assertEqual(res.status_code, 302)
mock_create.return_value.create_volume.assert_not_called()
def test_edit_volume_accepts_valid_options(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm:
proxy = mock_wvm.return_value
self._mock_disk_options(proxy)
res = self._post(
"edit_volume",
{
"edit_volume": "1",
"dev": "vda",
"vol_path": VM_DISK["path"],
"vol_bus_old": "virtio",
"vol_bus": "virtio",
"vol_format": "qcow2",
"vol_serial": "SER-01",
"vol_cache": "none",
"vol_io_mode": "native",
"vol_discard_mode": "unmap",
"vol_detect_zeroes": "on",
},
)
self.assertEqual(res.status_code, 302)
proxy.edit_disk.assert_called_once_with(
"vda", VM_DISK["path"], False, False, "virtio", "SER-01", "qcow2",
"none", "native", "unmap", "on",
)
def _edit_volume_post(self, **extra):
data = {
"edit_volume": "1",
"dev": "vda",
"vol_path": VM_DISK["path"],
"vol_bus_old": "virtio",
"vol_bus": "virtio",
"vol_format": "qcow2",
"vol_cache": "none",
}
data.update(extra)
return self._post("edit_volume", data)
def test_edit_volume_bus_change_keeps_the_disk_and_applies_options(self):
from vrtManager.instance import wvmInstance
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance", autospec=wvmInstance) as mock_wvm:
proxy = mock_wvm.return_value
self._mock_disk_options(proxy)
proxy.get_status.return_value = 1
res = self._edit_volume_post(vol_bus="sata")
self.assertEqual(res.status_code, 302)
proxy.attach_disk.assert_not_called()
proxy.detach_disk.assert_not_called()
proxy.edit_disk.assert_called_once()
self.assertEqual(proxy.edit_disk.call_args.args[0], "vda")
self.assertEqual(proxy.edit_disk.call_args.args[4], "sata")
def test_edit_volume_keeps_current_format_when_field_is_none_or_empty(self):
self.client.force_login(self.superuser)
for value in ("None", ""):
with self.subTest(vol_format=value), patch("instances.models.wvmInstance") as mock_wvm:
proxy = mock_wvm.return_value
self._mock_disk_options(proxy)
self._edit_volume_post(vol_format=value)
proxy.edit_disk.assert_called_once()
self.assertEqual(proxy.edit_disk.call_args[0][6], VM_DISK["format"])
def test_disk_names_with_trailing_newline_are_rejected(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmCreate"
) as mock_create, patch("instances.views.wvmStorage"):
self._mock_disk_options(mock_wvm.return_value)
self._post(
"add_new_vol",
{"storage": "default", "name": "disk\n", "format": "qcow2", "size": "1",
"bus": "virtio", "cache": "default"},
)
mock_create.return_value.create_volume.assert_not_called()
def test_add_new_vol_attaches_the_format_the_pool_created(self):
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm, patch(
"instances.views.wvmCreate"
) as mock_create, patch("instances.views.wvmStorage") as mock_storage:
proxy = mock_wvm.return_value
self._mock_disk_options(proxy)
mock_create.return_value.create_volume.return_value = "/mnt/nfs/disk.img"
pool = mock_storage.return_value
pool.get_type.return_value = "netfs"
pool.get_volume_type.return_value = "file"
pool.get_volume_format_type.return_value = "raw" # a netfs pool creates raw
self._post(
"add_new_vol",
{"storage": "nfs", "name": "disk", "format": "qcow2", "size": "1", "bus": "virtio", "cache": "default"},
)
pool.get_volume_format_type.assert_called_once_with("disk.img")
self.assertEqual(proxy.attach_disk.call_args.kwargs["format_type"], "raw")
def test_edit_volume_accepts_a_disk_without_any_driver_format(self):
self.client.force_login(self.superuser)
no_format_disk = dict(VM_DISK, format=None)
with patch("instances.models.wvmInstance") as mock_wvm:
proxy = mock_wvm.return_value
self._mock_disk_options(proxy)
proxy.get_disk_devices.return_value = [no_format_disk]
self._edit_volume_post(vol_format="None")
proxy.edit_disk.assert_called_once()
self.assertEqual(proxy.edit_disk.call_args[0][6], "")

View file

@ -0,0 +1,28 @@
"""drbd_status runs ssh with the compute's login@hostname; a compute whose
values would inject an ssh option (an existing or bypassed row) is skipped,
and a compute that does not answer in time leaves the status unknown."""
import subprocess
import unittest
from types import SimpleNamespace
from unittest.mock import patch
from instances.views import DRBD_STATUS_TIMEOUT, _valid_ssh_target, drbd_status
class DrbdTargetTestCase(unittest.TestCase):
def test_valid_target(self):
self.assertTrue(_valid_ssh_target(SimpleNamespace(login="root", hostname="192.0.2.1")))
def test_option_injection_is_skipped(self):
for login, hostname in (("-oProxyCommand=x", "192.0.2.1"), ("root", "-x"), ("root", "a b")):
with self.subTest(login=login, hostname=hostname):
self.assertFalse(_valid_ssh_target(SimpleNamespace(login=login, hostname=hostname)))
def test_a_compute_that_does_not_answer_leaves_the_status_unknown(self):
vm = SimpleNamespace(name="vm1", compute=SimpleNamespace(type=2, login="root", hostname="192.0.2.1"))
with patch("instances.views.get_instance", return_value=vm), patch(
"instances.views.subprocess.run", side_effect=subprocess.TimeoutExpired("ssh", DRBD_STATUS_TIMEOUT)
) as run:
self.assertEqual(drbd_status(SimpleNamespace(user=None), 1), "None DRBD")
self.assertEqual(run.call_args.kwargs["timeout"], DRBD_STATUS_TIMEOUT)

View file

@ -0,0 +1,142 @@
"""Failures reach the user: safe redirects, failure statuses, no silent success."""
import inspect
from unittest.mock import patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import URLPattern, get_resolver, reverse
from logs.models import Logs
from vrtManager.util import OperationError
from instances.models import Instance
EXTERNAL = "https://evil.example/instances/1/"
def back_views():
"""URL names of the instance views that return with _back()."""
names = []
for pattern in get_resolver().url_patterns:
if getattr(pattern, "namespace", None) != "instances":
continue
for sub in pattern.url_patterns:
if isinstance(sub, URLPattern) and "_back(request, pk" in inspect.getsource(inspect.unwrap(sub.callback)):
names.append(sub.name)
return names
class ErrorHandlingTestCase(TestCase):
def setUp(self):
admin = get_user_model().objects.create_superuser("err_admin", "e@example.com", "pw")
self.client.force_login(admin)
self.compute = Compute.objects.create(name="err-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=self.compute, name="err-vm", uuid="11111111-2222-3333-4444-555555555555"
)
self.page = f"/instances/{self.instance.id}/"
def url(self, name):
args = [self.instance.id, "sda"] if name == "detach_cdrom" else [self.instance.id]
return reverse(f"instances:{name}", args=args)
# Required fields for the views that 404 without them
DATA = {
"add_owner": lambda self: {"user_id": get_user_model().objects.get(username="err_admin").id},
"del_owner": lambda self: {"userinstance": UserInstance.objects.get_or_create(
instance=self.instance, user=get_user_model().objects.get(username="err_admin"))[0].id},
"add_network": lambda self: {"add-net-network": "net:default"},
"set_qos": lambda self: {"qos_direction": "inbound", "net-mac-0": "52:54:00:00:00:01"},
}
def test_redirects_without_or_with_a_foreign_referer_go_to_the_vm_page(self):
names = back_views()
self.assertGreaterEqual(len(names), 30)
for name in names:
for referer in (None, EXTERNAL):
with self.subTest(view=name, referer=referer), patch("instances.models.wvmInstance"):
headers = {"HTTP_REFERER": referer} if referer else {}
data = self.DATA[name](self) if name in self.DATA else {}
response = self.client.post(self.url(name), data, **headers)
self.assertEqual(response.status_code, 302)
self.assertTrue(response.url.startswith(self.page + "#"), response.url)
def test_owner_views_reject_missing_or_foreign_ids(self):
other = Instance.objects.create(compute=self.compute, name="other", uuid="11111111-2222-3333-4444-777777777777")
foreign = UserInstance.objects.create(instance=other, user=get_user_model().objects.get(username="err_admin"))
self.assertEqual(self.client.post(self.url("add_owner"), {}).status_code, 404)
self.assertEqual(self.client.post(self.url("del_owner"), {}).status_code, 404)
self.assertEqual(self.client.post(self.url("del_owner"), {"userinstance": foreign.id}).status_code, 404)
self.assertTrue(UserInstance.objects.filter(pk=foreign.id).exists())
def test_same_site_referer_is_kept(self):
with patch("instances.models.wvmInstance"):
response = self.client.post(self.url("set_autostart"), {}, HTTP_REFERER="http://testserver/instances/?x=1")
self.assertEqual(response.url, "http://testserver/instances/?x=1#boot_opt")
def migrate(self, target_id, up=True):
with patch("instances.models.wvmInstance"), patch.object(Compute, "status", up):
return self.client.post(self.url("migrate"), {"compute_id": target_id})
def test_migrate_to_a_down_host_is_reported_and_not_logged_as_done(self):
target = Compute.objects.create(name="down", hostname="10.0.0.9", login="", password="", type=4)
response = self.migrate(str(target.id), up=False)
self.assertEqual(response.status_code, 302)
self.assertIn("not reachable", " ".join(str(m) for m in get_messages(response.wsgi_request)))
self.assertFalse(Logs.objects.filter(message__contains="migrated").exists())
def test_migrate_to_the_same_host_is_reported(self):
response = self.migrate(str(self.compute.id))
self.assertIn("already on", " ".join(str(m) for m in get_messages(response.wsgi_request)))
def test_migrate_to_an_invalid_compute_is_404(self):
self.assertEqual(self.migrate("").status_code, 404)
self.assertEqual(self.migrate("999").status_code, 404)
class ApiErrorTestCase(TestCase):
def setUp(self):
admin = get_user_model().objects.create_superuser("api_admin", "a@example.com", "pw")
self.client.force_login(admin)
self.compute = Compute.objects.create(name="api-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=self.compute, name="api-vm", uuid="11111111-2222-3333-4444-666666666666"
)
def test_libvirt_error_is_json_with_a_failure_status(self):
url = reverse("compute-instance-poweron", kwargs={"compute_pk": self.compute.id, "pk": self.instance.id})
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.start.side_effect = OperationError("cannot start")
response = self.client.post(url, {})
self.assertEqual(response.status_code, 400)
self.assertEqual(response.json(), {"detail": "cannot start"})
def test_migrate_to_a_down_host_is_not_started(self):
target = Compute.objects.create(name="api-down", hostname="10.0.0.9", login="", password="", type=4)
with patch("instances.models.wvmInstance"), patch.object(Compute, "status", False):
response = self.client.post(
reverse("instance-migrate-list"), {"instance": self.instance.id, "target_compute": target.id}
)
self.assertEqual(response.status_code, 400)
self.assertIn("not reachable", response.json()["detail"])
def volume(self, method, active=True, data=None):
kwargs = {"compute_pk": self.compute.id, "storage_pk": "default"}
with patch("storages.api.viewsets.wvmStorage") as storage:
storage.return_value.is_active.return_value = active
if method == "post":
return self.client.post(reverse("compute-storage-volumes-list", kwargs=kwargs), data or {})
return self.client.delete(reverse("compute-storage-volumes-detail", kwargs={**kwargs, "pk": "disk.qcow2"}))
def test_volume_calls_on_an_inactive_pool_fail(self):
data = {"name": "v", "size": 1, "type": "qcow2", "meta_prealloc": False}
self.assertEqual(self.volume("post", active=False, data=data).status_code, 409)
self.assertEqual(self.volume("delete", active=False).status_code, 409)
def test_invalid_volume_data_is_400_with_the_errors(self):
response = self.volume("post", data={})
self.assertEqual(response.status_code, 400)
self.assertIn("name", response.json())

View file

@ -0,0 +1,502 @@
import json
import os
import socket
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
GSTFSD = Path(__file__).resolve().parent.parent.parent / "conf" / "daemon" / "gstfsd"
# A stand-in for libguestfs: the guest's operating systems ("roots", each with
# its mountpoints), its files, and what is mounted live in a JSON file.
FAKE_GUESTFS = '''
import json, os
STATE = os.environ["FAKE_GUESTFS_STATE"]
def _load():
with open(STATE) as f:
return json.load(f)
def _save(state):
with open(STATE, "w") as f:
json.dump(state, f)
class GuestFS:
def __init__(self, **kwargs):
if _load().get("crash"):
import sys
sys.stderr.write("guestfs: the appliance crashed\\n")
os._exit(3)
self.launched = False
def add_domain(self, name, **kwargs):
if _load().get("fail_add"):
raise RuntimeError("no domain named " + name)
def launch(self):
import time
if _load().get("appliance"):
# a stand-in for the appliance: a child process, like qemu
import subprocess
child = subprocess.Popen(["sleep", "60"])
state = _load(); state["appliance_pid"] = child.pid; _save(state)
time.sleep(_load().get("launch_seconds", 0))
state = _load(); state["backend"] = os.environ.get("LIBGUESTFS_BACKEND"); _save(state)
self.launched = True
def inspect_os(self): return list(_load()["roots"])
def inspect_get_mountpoints(self, root): return _load()["roots"][root]
def mount(self, device, mountpoint):
state = _load()
if device in state.get("broken", []):
raise RuntimeError("mount: wrong fs type on " + device)
# a mountpoint needs its parent filesystem mounted first
if mountpoint != "/" and "/" not in state["mounted"]:
raise RuntimeError("mount: " + mountpoint + " does not exist")
state["mounted"].append(mountpoint); state["history"].append([device, mountpoint]); _save(state)
def umount_all(self):
if not self.launched:
raise RuntimeError("umount_all: call launch before using this function")
state = _load(); state["mounted"] = []; _save(state)
def shutdown(self):
if not self.launched:
raise RuntimeError("shutdown: call launch before using this function")
def close(self):
state = _load(); state["closed"] = True; _save(state)
def _guest(self):
if "/" not in _load()["mounted"]:
raise RuntimeError("the guest root is not mounted")
def is_file(self, path): self._guest(); return path in _load()["files"]
def is_dir(self, path): self._guest(); return path in _load()["dirs"]
def cat(self, path): self._guest(); return _load()["files"][path]
def write(self, path, content):
self._guest()
import time
time.sleep(_load().get("write_seconds", 0))
state = _load()
if state.get("fail_write"):
raise RuntimeError("write: read-only file system")
state["files"][path] = content; state["writes"] += 1; _save(state)
def mkdir(self, path):
self._guest(); state = _load(); state["dirs"].append(path); _save(state)
def chmod(self, mode, path): self._guest()
def feature_available(self, names): return not _load().get("no_selinuxrelabel")
def selinux_relabel(self, specfile, path, force=None):
self._guest(); state = _load()
if specfile not in state["files"]:
raise RuntimeError("selinux_relabel: " + specfile + ": No such file or directory")
# with the number of writes before it: labels are set on written files
state.setdefault("relabels", []).append([specfile, path, force, state["writes"]]); _save(state)
'''
def free_port(family=socket.AF_INET, host="127.0.0.1"):
with socket.socket(family, socket.SOCK_STREAM) as s:
s.bind((host, 0))
return s.getsockname()[1]
class GstfsdTestCase(unittest.TestCase):
"""gstfsd hardening."""
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
self.addCleanup(self.tmp.cleanup)
Path(self.tmp.name, "guestfs.py").write_text(FAKE_GUESTFS)
self.state = Path(self.tmp.name, "state.json")
self.state.write_text(json.dumps({
# one Linux guest with its root on LVM and a separate /boot
"roots": {"/dev/vg/root": {"/": "/dev/vg/root", "/boot": "/dev/sda1"}},
"files": {"/etc/shadow": "root:x:1::::::\n", "/root/.ssh/authorized_keys": "ssh-rsa OLD old@host\n"},
"dirs": ["/root/.ssh"],
"mounted": [],
"history": [],
"writes": 0,
}))
def _env(self, **extra):
return dict(
os.environ,
PYTHONPATH=self.tmp.name,
FAKE_GUESTFS_STATE=str(self.state),
**extra,
)
def _start(self, host, port, family=socket.AF_INET, **env):
proc = subprocess.Popen(
[sys.executable, str(GSTFSD)],
env=self._env(GSTFSD_BIND_HOST=host, GSTFSD_PORT=str(port), **env),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
)
self.addCleanup(proc.wait)
self.addCleanup(proc.kill)
for _ in range(100):
if proc.poll() is not None:
self.fail("gstfsd exited: " + proc.stderr.read())
try:
with socket.socket(family, socket.SOCK_STREAM) as s:
s.connect((host, port))
return proc
except OSError:
time.sleep(0.05)
self.fail("gstfsd did not start listening")
def _request(self, host, port, data, family=socket.AF_INET):
with socket.socket(family, socket.SOCK_STREAM) as s:
s.settimeout(10)
s.connect((host, port))
s.sendall(json.dumps(data).encode())
# everything until gstfsd closes: more than one reply fails to parse
return json.loads(b"".join(iter(lambda: s.recv(4096), b"")))
def test_refuses_non_loopback_bind_without_opt_in(self):
result = subprocess.run(
[sys.executable, str(GSTFSD)],
env=self._env(GSTFSD_BIND_HOST="0.0.0.0"),
capture_output=True,
text=True,
timeout=20,
)
self.assertNotEqual(result.returncode, 0)
self.assertIn("GSTFSD_ALLOW_REMOTE", result.stderr)
def test_public_key_is_appended_not_overwritten(self):
port = free_port()
self._start("127.0.0.1", port)
reply = self._request(
"127.0.0.1", port, {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 NEW new@host"}
)
self.assertEqual(reply["return"], "success")
keys = json.loads(self.state.read_text())["files"]["/root/.ssh/authorized_keys"]
self.assertEqual(keys.splitlines(), ["ssh-rsa OLD old@host", "ssh-ed25519 NEW new@host"])
@unittest.skipUnless(socket.has_ipv6, "no IPv6")
def test_refuses_a_deadline_the_panel_does_not_wait_for(self):
# the panel gives up after 120 s and releases the VM
proc = subprocess.run(
[sys.executable, str(GSTFSD)],
env=self._env(GSTFSD_PORT=str(free_port()), GSTFSD_DEADLINE="180"),
capture_output=True, text=True, timeout=10,
)
self.assertNotEqual(proc.returncode, 0)
self.assertIn("GSTFSD_DEADLINE", proc.stderr)
def test_listens_on_ipv6_loopback(self):
try:
port = free_port(socket.AF_INET6, "::1")
except OSError:
self.skipTest("IPv6 loopback not available")
self._start("::1", port, socket.AF_INET6)
reply = self._request(
"::1", port, {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 V6 v6@host"},
socket.AF_INET6,
)
self.assertEqual(reply["return"], "success")
def _update_state(self, **values):
state = json.loads(self.state.read_text())
state.update(values)
self.state.write_text(json.dumps(state))
def _serve(self):
port = free_port()
self._start("127.0.0.1", port)
return port
def test_root_password_is_set_on_the_guest_root(self):
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$new"})
self.assertEqual(reply, {"return": "success"})
state = json.loads(self.state.read_text())
self.assertEqual(state["files"]["/etc/shadow"], "root:$6$new:1::::::\n")
self.assertEqual(state["mounted"], [])
self.assertTrue(state["closed"])
def test_no_or_several_operating_systems_give_one_error(self):
for roots in ({}, {"/dev/sda1": {"/": "/dev/sda1"}, "/dev/sdb1": {"/": "/dev/sdb1"}}):
with self.subTest(roots=list(roots)):
self._update_state(roots=roots)
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$x"})
self.assertEqual(reply["return"], "error")
self.assertEqual(json.loads(self.state.read_text())["files"]["/etc/shadow"], "root:x:1::::::\n")
def test_a_failed_change_gives_one_error_and_cleans_up(self):
self._update_state(fail_write=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$x"})
self.assertEqual(reply["return"], "error")
self.assertIn("read-only", reply["message"])
state = json.loads(self.state.read_text())
self.assertEqual(state["mounted"], [])
self.assertTrue(state["closed"])
def test_a_long_key_arrives_whole(self):
# longer than one read of the daemon (4096 bytes)
key = "ssh-rsa " + "A" * 6000 + " long@host"
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": key})
self.assertEqual(reply, {"return": "success"})
keys = json.loads(self.state.read_text())["files"]["/root/.ssh/authorized_keys"]
self.assertEqual(keys.splitlines()[-1], key)
def test_the_root_is_mounted_before_the_filesystems_under_it(self):
self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$x"})
self.assertEqual(
json.loads(self.state.read_text())["history"], [["/dev/vg/root", "/"], ["/dev/sda1", "/boot"]]
)
def test_a_broken_unrelated_filesystem_does_not_block_the_change(self):
self._update_state(broken=["/dev/sda1"]) # /boot
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$y"})
self.assertEqual(reply, {"return": "success"})
self.assertEqual(json.loads(self.state.read_text())["files"]["/etc/shadow"], "root:$6$y:1::::::\n")
def test_a_broken_filesystem_on_the_path_blocks_the_change(self):
state = json.loads(self.state.read_text())
state["roots"]["/dev/vg/root"]["/root"] = "/dev/vg/home"
state["broken"] = ["/dev/vg/home"]
self.state.write_text(json.dumps(state))
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K k@host"})
self.assertEqual(reply["return"], "error")
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_root_is_found_anywhere_in_shadow(self):
self._update_state(files={"/etc/shadow": "daemon:*:1::::::\nroot:x:1::::::\n"})
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$z"})
self.assertEqual(reply, {"return": "success"})
self.assertEqual(
json.loads(self.state.read_text())["files"]["/etc/shadow"], "daemon:*:1::::::\nroot:$6$z:1::::::\n"
)
def test_a_shadow_without_root_is_an_error(self):
self._update_state(files={"/etc/shadow": "daemon:*:1::::::\n"})
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$z"})
self.assertEqual(reply["return"], "error")
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_an_early_failure_keeps_its_own_message(self):
self._update_state(fail_add=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$x"})
self.assertEqual(reply["return"], "error")
self.assertIn("no domain named vm", reply["message"])
def test_a_request_in_two_pieces(self):
port = self._serve()
body = json.dumps({"action": "password", "vname": "vm", "passwd": "$6$parts"}).encode()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(10)
s.connect(("127.0.0.1", port))
s.sendall(body[:10])
time.sleep(0.3)
s.sendall(body[10:])
reply = json.loads(b"".join(iter(lambda: s.recv(4096), b"")))
self.assertEqual(reply, {"return": "success"})
def test_a_request_over_the_limit_is_refused(self):
port = self._serve()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(10)
s.connect(("127.0.0.1", port))
s.sendall(b'{"action": "publickey", "vname": "vm", "key": "' + b"A" * 70000 + b'"}')
reply = json.loads(b"".join(iter(lambda: s.recv(4096), b"")))
self.assertEqual(reply["return"], "error")
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_a_trickling_client_is_cut_off(self):
port = free_port()
self._start("127.0.0.1", port, GSTFSD_DEADLINE="2")
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect(("127.0.0.1", port))
s.settimeout(0.25)
start = time.monotonic()
reply = b""
# a space every quarter second: each read is quick, the request never completes
while not reply and time.monotonic() - start < 8:
try:
s.sendall(b" ")
reply = s.recv(4096)
except socket.timeout:
pass
except OSError:
break
self.assertTrue(reply, "gstfsd kept reading a request that never completes")
self.assertEqual(json.loads(reply)["return"], "error")
def test_a_slow_write_is_stopped_at_the_deadline(self):
# the whole change is bounded, not only its start: a write still
# running at the deadline is killed with the appliance
port = free_port()
self._start("127.0.0.1", port, GSTFSD_DEADLINE="1")
self._update_state(write_seconds=3)
start = time.monotonic()
reply = self._request("127.0.0.1", port, {"action": "password", "vname": "vm", "passwd": "$6$late"})
self.assertLess(time.monotonic() - start, 2.5)
self.assertEqual(reply["return"], "error")
time.sleep(3) # longer than the write would have taken
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_a_key_needs_no_shadow_file(self):
self._update_state(files={"/root/.ssh/authorized_keys": ""})
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K k@host"})
self.assertEqual(reply, {"return": "success"})
def _selinux_guest(self, selinuxtype="targeted", quote="", mode="enforcing"):
state = json.loads(self.state.read_text())
state["files"]["/etc/selinux/config"] = "SELINUX=%s\nSELINUXTYPE=%s%s%s\n" % (mode, quote, selinuxtype, quote)
state["files"]["/etc/selinux/%s/contexts/files/file_contexts" % selinuxtype] = ""
self.state.write_text(json.dumps(state))
def test_a_key_gets_the_selinux_labels_of_the_guest(self):
# a file libguestfs creates has no label, and sshd may not read an unlabeled authorized_keys
port = self._serve()
for i, quote in enumerate(("", '"', "'")):
with self.subTest(quote=quote):
self._selinux_guest("mls", quote)
reply = self._request("127.0.0.1", port, {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K%d k@host" % i})
self.assertEqual(reply, {"return": "success"})
state = json.loads(self.state.read_text())
# once, after the key is written
self.assertEqual(len(state.get("relabels", [])), i + 1)
self.assertEqual(
state["relabels"][-1], ["/etc/selinux/mls/contexts/files/file_contexts", "/root/.ssh", True, state["writes"]]
)
def test_a_guest_without_selinux_is_not_relabeled(self):
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K k@host"})
self.assertEqual(reply, {"return": "success"})
self.assertNotIn("relabels", json.loads(self.state.read_text()))
def test_a_guest_with_selinux_disabled_is_not_relabeled(self):
# enabling SELinux again relabels the whole guest
self._selinux_guest(mode="disabled")
self._update_state(no_selinuxrelabel=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K k@host"})
self.assertEqual(reply, {"return": "success"})
self.assertNotIn("relabels", json.loads(self.state.read_text()))
def test_a_key_for_a_selinux_guest_needs_a_host_that_can_label(self):
self._selinux_guest()
self._update_state(no_selinuxrelabel=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "publickey", "vname": "vm", "key": "ssh-ed25519 K k@host"})
self.assertEqual(reply["return"], "error")
self.assertIn("SELinux", reply["message"])
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_a_password_keeps_the_label_of_the_existing_shadow(self):
# rewriting /etc/shadow keeps its file and label: no labelling needed
self._selinux_guest()
self._update_state(no_selinuxrelabel=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$x"})
self.assertEqual(reply, {"return": "success"})
self.assertNotIn("relabels", json.loads(self.state.read_text()))
def test_a_client_that_leaves_does_not_break_the_service(self):
port = free_port()
proc = self._start("127.0.0.1", port, GSTFSD_DEADLINE="1")
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect(("127.0.0.1", port))
s.sendall(b'{"action": ')
time.sleep(1.5) # gstfsd times the request out and answers a closed socket
reply = self._request("127.0.0.1", port, {"action": "password", "vname": "vm", "passwd": "$6$after"})
self.assertEqual(reply, {"return": "success"})
proc.kill()
self.assertNotIn("Traceback", proc.stderr.read())
def test_nothing_is_written_after_the_deadline(self):
# the panel gives up after its timeout; gstfsd must not write later
port = free_port()
self._start("127.0.0.1", port, GSTFSD_DEADLINE="1")
self._update_state(launch_seconds=2)
reply = self._request("127.0.0.1", port, {"action": "password", "vname": "vm", "passwd": "$6$late"})
self.assertEqual(reply["return"], "error")
state = json.loads(self.state.read_text())
self.assertEqual(state["writes"], 0)
self.assertEqual(state["mounted"], [])
def test_the_appliance_runs_where_the_deadline_can_kill_it(self):
# a libvirt-started appliance is no child of the worker: killing the
# worker's process group would leave it writing to the disks
port = free_port()
self._start("127.0.0.1", port, LIBGUESTFS_BACKEND="libvirt")
reply = self._request("127.0.0.1", port, {"action": "password", "vname": "vm", "passwd": "$6$d"})
self.assertEqual(reply, {"return": "success"})
self.assertEqual(json.loads(self.state.read_text())["backend"], "direct")
def test_reading_the_request_counts_toward_the_deadline(self):
# the panel waits a fixed time from connecting; a slow request leaves
# less time for the change, not more
port = free_port()
self._start("127.0.0.1", port, GSTFSD_DEADLINE="2")
self._update_state(launch_seconds=3)
request = json.dumps({"action": "password", "vname": "vm", "passwd": "$6$slow"}).encode()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(10)
s.connect(("127.0.0.1", port))
start = time.monotonic()
s.sendall(request[:10])
time.sleep(1.5)
s.sendall(request[10:])
reply = json.loads(b"".join(iter(lambda: s.recv(4096), b"")))
self.assertEqual(reply["return"], "error")
self.assertLess(time.monotonic() - start, 2.8)
def test_a_crashed_worker_tells_why(self):
self._update_state(crash=True)
reply = self._request("127.0.0.1", self._serve(), {"action": "password", "vname": "vm", "passwd": "$6$c"})
self.assertEqual(reply["return"], "error")
self.assertIn("the appliance crashed", reply["message"])
def test_a_client_that_leaves_stops_the_change(self):
# the panel releases the VM when its connection breaks: nothing may
# change the disks after that
port = free_port()
self._start("127.0.0.1", port)
self._update_state(launch_seconds=2)
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.connect(("127.0.0.1", port))
s.sendall(json.dumps({"action": "password", "vname": "vm", "passwd": "$6$gone"}).encode())
time.sleep(0.5)
time.sleep(3) # longer than the change would have taken
self.assertEqual(json.loads(self.state.read_text())["writes"], 0)
def test_the_reply_waits_until_the_appliance_is_gone(self):
port = free_port()
self._start("127.0.0.1", port, GSTFSD_DEADLINE="1")
self._update_state(appliance=True, launch_seconds=3)
reply = self._request("127.0.0.1", port, {"action": "password", "vname": "vm", "passwd": "$6$late"})
self.assertEqual(reply["return"], "error")
pid = json.loads(self.state.read_text())["appliance_pid"]
try:
with open("/proc/%d/stat" % pid) as f:
state = f.read().rsplit(")", 1)[1].split()[0]
except FileNotFoundError:
state = "gone"
self.assertIn(state, ("gone", "Z"))
class GstfsdClientTestCase(unittest.TestCase):
"""The panel side sends the whole request and reads the whole reply."""
def test_a_reply_in_pieces_is_read_whole(self):
import threading
from unittest.mock import patch
from instances import views
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 0))
server.listen(1)
self.addCleanup(server.close)
received = []
def serve():
conn, _ = server.accept()
with conn:
received.append(conn.recv(65536))
conn.sendall(b'{"return": ')
time.sleep(0.2)
conn.sendall(b'"success"}')
thread = threading.Thread(target=serve)
thread.start()
with patch.object(views, "GSTFSD_PORT", server.getsockname()[1]):
reply = views.gstfsd_request("127.0.0.1", {"action": "publickey", "vname": "vm", "key": "k"})
thread.join(5)
self.assertEqual(reply, {"return": "success"})
self.assertEqual(json.loads(received[0])["vname"], "vm")

View file

@ -0,0 +1,44 @@
"""Tests for the instances list after out-of-band libvirt changes."""
from unittest.mock import PropertyMock, patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
class InstancesIndexTests(TestCase):
def test_removed_domain_is_not_rendered_from_prefetch_cache(self):
user = get_user_model().objects.create_superuser(
username="instances-index-admin", password="password", email="index@example.com"
)
self.client.force_login(user)
compute = Compute.objects.create(
name="index-compute", hostname="localhost", type=4,
login="", password="",
)
instance = Instance.objects.create(
compute=compute, name="test4", uuid="cb2a2697-0945-408a-ac6b-c3e07a280851"
)
self.assertEqual(Compute.objects.count(), 1)
def synchronize(_compute):
Instance.objects.filter(pk=instance.pk).delete()
self.assertFalse(Instance.objects.filter(pk=instance.pk).exists())
with patch("instances.views.utils.refr", side_effect=synchronize), patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
), patch.object(
Compute, "cpu_count", new_callable=PropertyMock, return_value=1
), patch.object(
Compute, "ram_size", new_callable=PropertyMock, return_value=1024
), patch.object(
Compute, "ram_usage", new_callable=PropertyMock, return_value=0
):
response = self.client.get(reverse("instances:index"))
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, "test4")
self.assertEqual(list(response.context["computes"][0].instance_set.all()), [])

View file

@ -0,0 +1,63 @@
"""Host connection errors on the instance list: administrators see which host
and why; other users only learn that a host of their own VMs is unreachable."""
from unittest.mock import PropertyMock, patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
USER_MESSAGE = "A host of some of your virtual machines cannot be reached right now."
class IndexHostAlertTests(TestCase):
def setUp(self):
User = get_user_model()
self.user = User.objects.create_user(username="tenant", password="pwd")
self.mine = Compute.objects.create(name="mine-host", hostname="10.0.0.1", type=1, login="u", password="p")
self.other = Compute.objects.create(name="other-host", hostname="10.0.0.2", type=1, login="u", password="p")
vm = Instance.objects.create(compute=self.mine, name="tenant-vm", uuid="11111111-1111-1111-1111-111111111111")
UserInstance.objects.create(instance=vm, user=self.user)
def get(self, user, down):
def status(compute):
return compute.name not in down
def error(compute):
return None if status(compute) else f"Connection Failed: no route to {compute.hostname}"
self.client.force_login(user)
with patch("instances.views.utils.refr"), patch.object(Compute, "status", property(status)), patch.object(
Compute, "connection_error", property(error)
), patch.object(Instance, "info", new_callable=PropertyMock, return_value=None):
response = self.client.get(reverse("instances:index"))
self.assertEqual(response.status_code, 200)
return response
def test_user_sees_no_infrastructure_details(self):
response = self.get(self.user, down={"mine-host", "other-host"})
self.assertContains(response, USER_MESSAGE, count=1)
for text in ("mine-host", "other-host", "10.0.0.1", "10.0.0.2", "Connection Failed"):
self.assertNotContains(response, text)
def test_user_is_not_told_about_hosts_without_their_vms(self):
response = self.get(self.user, down={"other-host"})
self.assertNotContains(response, USER_MESSAGE)
self.assertNotContains(response, "other-host")
def test_superuser_sees_each_host_and_its_error(self):
admin = get_user_model().objects.create_superuser(username="root", password="pwd", email="r@example.com")
response = self.get(admin, down={"mine-host", "other-host"})
self.assertContains(response, "Connection Failed: no route to 10.0.0.1")
self.assertContains(response, "Connection Failed: no route to 10.0.0.2")
self.assertNotContains(response, USER_MESSAGE)
def test_global_viewer_sees_each_host_and_its_error(self):
viewer = get_user_model().objects.create_user(username="viewer", password="pwd")
viewer.user_permissions.add(Permission.objects.get(codename="view_instances"))
response = self.get(viewer, down={"other-host"})
self.assertContains(response, "Connection Failed: no route to 10.0.0.2")

View file

@ -0,0 +1,86 @@
"""Instance lists ask libvirt for a VM's info once per row."""
from types import SimpleNamespace
from unittest.mock import PropertyMock, patch
from appsettings.models import AppSettings
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
# virDomainGetInfo: state, max memory KiB, memory KiB, vCPUs, CPU time
INFO = [1, 4194304, 2097152, 3, 0]
class FakeDomain:
# a plain class: Django templates do not call MagicMock attributes
def __init__(self):
self.info_calls = 0
self.xml_calls = 0
def info(self):
self.info_calls += 1
return INFO
def XMLDesc(self, flags=0):
self.xml_calls += 1
return "<domain><title></title><currentMemory>2097152</currentMemory></domain>"
class ListInfoCallTests(TestCase):
def setUp(self):
self.client.force_login(
get_user_model().objects.create_superuser(username="rpc-admin", password="pwd", email="rpc@example.com")
)
self.compute = Compute.objects.create(name="rpc-compute", hostname="localhost", type=4, login="", password="")
Instance.objects.create(compute=self.compute, name="vm-a", uuid="11111111-1111-1111-1111-111111111111")
Instance.objects.create(compute=self.compute, name="vm-b", uuid="22222222-2222-2222-2222-222222222222")
self.domains = []
def proxy(self, *args, **kwargs):
domain = FakeDomain()
self.domains.append(domain)
return SimpleNamespace(
instance=domain,
get_uuid=lambda: "uuid",
get_title=lambda: domain.XMLDesc() and "",
get_cur_memory=lambda: int(domain.XMLDesc().split(">")[4].split("<")[0]) // 1024,
)
def get(self, url):
compute_patches = {"status": True, "cpu_count": 1, "ram_size": 1024, "ram_usage": 0}
with patch("instances.views.utils.refr"), patch("computes.views.utils.refresh_instance_database"), patch(
"instances.models.wvmInstance", side_effect=self.proxy
):
patches = [patch.object(Compute, k, new_callable=PropertyMock, return_value=v) for k, v in compute_patches.items()]
for p in patches:
p.start()
try:
response = self.client.get(url)
finally:
for p in patches:
p.stop()
self.assertEqual(response.status_code, 200)
return response
def assert_one_info_per_vm(self, response, memory="2048 MB"):
self.assertEqual(len(self.domains), 2, "one proxy per VM row")
for domain in self.domains:
self.assertEqual(domain.info_calls, 1)
self.assertEqual(domain.xml_calls, 1, "only the title reads the XML")
self.assertContains(response, memory, count=2)
self.assertContains(response, "Active")
def test_nongrouped_index(self):
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="nongrouped")
self.assert_one_info_per_vm(self.get(reverse("instances:index")))
def test_grouped_index(self):
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="grouped")
self.assert_one_info_per_vm(self.get(reverse("instances:index")))
def test_compute_instances(self):
# this page shows the maximum memory, as before
self.assert_one_info_per_vm(self.get(reverse("instances", args=[self.compute.id])), memory="4096 MiB")

View file

@ -0,0 +1,107 @@
"""A VM that cannot be read shows as unknown in the lists instead of turning
the whole page into an error page (host down, failed sync, VM gone)."""
from types import SimpleNamespace
from unittest.mock import PropertyMock, patch
from appsettings.models import AppSettings
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from vrtManager.util import OperationError
ERROR = "Connection Failed: No route to host"
UP_INFO = [1, 4194304, 2097152, 3, 0]
class Domain:
def info(self):
return UP_INFO
def live(*args, **kwargs):
return SimpleNamespace(instance=Domain(), get_title=lambda: "", get_uuid=lambda: "uuid")
def unreachable(*args, **kwargs):
raise OperationError(ERROR)
class UnreachableListTests(TestCase):
def setUp(self):
self.client.force_login(
get_user_model().objects.create_superuser(username="down-admin", password="pwd", email="down@example.com")
)
self.compute = Compute.objects.create(name="down-compute", hostname="192.0.2.1", type=1, login="u", password="p")
self.vm_a = Instance.objects.create(compute=self.compute, name="vm-a", uuid="11111111-1111-1111-1111-111111111111")
self.vm_b = Instance.objects.create(compute=self.compute, name="vm-b", uuid="22222222-2222-2222-2222-222222222222")
def get(self, url, wvm_instance, up=False):
def no_live_host_data(_self):
raise AssertionError("host data read for a host that is down")
props = {"status": up, "connection_error": None if up else ERROR}
patches = [patch.object(Compute, k, new_callable=PropertyMock, return_value=v) for k, v in props.items()]
for name in ("cpu_count", "ram_size", "ram_usage"):
if up:
patches.append(patch.object(Compute, name, new_callable=PropertyMock, return_value=1))
else:
patches.append(patch.object(Compute, name, property(no_live_host_data)))
patches += [
patch("instances.views.utils.refr"),
patch("computes.views.utils.refresh_instance_database"),
patch("instances.models.wvmInstance", side_effect=wvm_instance),
]
for p in patches:
p.start()
try:
response = self.client.get(url)
finally:
for p in reversed(patches):
p.stop()
self.assertEqual(response.status_code, 200)
return response
def assert_unknown(self, response, instances):
for vm in instances:
self.assertContains(response, vm.name)
self.assertNotContains(response, reverse("instances:poweron", args=[vm.id]))
self.assertNotContains(response, reverse("instances:poweroff", args=[vm.id]))
self.assertContains(response, "Unknown", count=len(instances))
def test_nongrouped_index_lists_the_vms_of_a_down_host(self):
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="nongrouped")
response = self.get(reverse("instances:index"), unreachable)
self.assert_unknown(response, [self.vm_a, self.vm_b])
self.assertContains(response, ERROR)
def test_grouped_index_lists_the_vms_of_a_down_host(self):
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="grouped")
response = self.get(reverse("instances:index"), unreachable)
self.assert_unknown(response, [self.vm_a, self.vm_b])
self.assertContains(response, "Not Connected")
def test_one_unreadable_vm_does_not_hide_the_others(self):
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="nongrouped")
def vm_b_gone(*args, uuid=None, **kwargs):
if uuid == self.vm_b.uuid:
raise OperationError("Domain not found")
return live()
response = self.get(reverse("instances:index"), vm_b_gone, up=True)
self.assert_unknown(response, [self.vm_b])
self.assertContains(response, reverse("instances:poweroff", args=[self.vm_a.id]))
def test_compute_instances_page_of_a_down_host(self):
response = self.get(reverse("instances", args=[self.compute.id]), unreachable)
self.assert_unknown(response, [self.vm_a, self.vm_b])
self.assertContains(response, ERROR)
def test_compute_instances_page_does_not_claim_a_down_host_is_empty(self):
Instance.objects.all().delete()
response = self.get(reverse("instances", args=[self.compute.id]), unreachable)
self.assertNotContains(response, "have any Instances")
self.assertContains(response, ERROR)

View file

@ -0,0 +1,117 @@
"""Live checks for cloning. Runs only with TEST_LIBVIRT_HOST set."""
import os
import unittest
from xml.etree import ElementTree
import libvirt
from django.test import SimpleTestCase
from vrtManager.connection import connection_manager
from vrtManager.instance import wvmInstance
from . import livetest
P = livetest.PREFIX
class LiveCloneTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.args = (
os.environ["TEST_LIBVIRT_HOST"],
os.environ.get("TEST_LIBVIRT_LOGIN", ""),
os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.args)
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def tearDown(self):
livetest.cleanup(self.conn)
def pool_volumes(self):
pool = self.conn.storagePoolLookupByName(livetest.POOL)
pool.refresh(0)
return set(pool.listVolumes())
def source(self, name):
disks = [livetest.create_volume(self.conn, P + f"{name}-{d}") for d in ("a", "b")]
dom = livetest.define_vm(self.conn, P + name, disks)
return dom, wvmInstance(*self.args, None, uuid=dom.UUIDString())
def clone_data(self, name):
return {
"name": P + name,
"disk-vda": P + name + "-a.qcow2",
"disk-vdb": P + name + "-b.qcow2",
"disk_owner_uid": 0,
"disk_owner_gid": 0,
}
def test_failed_clone_removes_only_its_own_copies(self):
_, vm = self.source("clone-src")
taken = livetest.create_volume(self.conn, P + "clone-dst-b") # destination of vdb exists
before = self.pool_volumes()
with self.assertRaises(Exception):
vm.clone_instance(self.clone_data("clone-dst"))
self.assertEqual(self.pool_volumes(), before, "copies left behind or a volume deleted")
self.assertTrue(livetest.volume_exists(self.conn, taken))
with self.assertRaises(libvirt.libvirtError):
self.conn.lookupByName(P + "clone-dst")
def test_running_vm_is_not_cloned(self):
dom, vm = self.source("clone-run")
dom.create()
before = self.pool_volumes()
with self.assertRaises(Exception):
vm.clone_instance(self.clone_data("clone-run-copy"))
self.assertEqual(self.pool_volumes(), before)
def test_clone_of_a_uefi_vm_has_its_own_copy_of_the_nvram(self):
disk = livetest.create_volume(self.conn, P + "clone-uefi-a")
dom = livetest.define_vm(self.conn, P + "clone-uefi", [disk], uefi=True)
dom.createWithFlags(libvirt.VIR_DOMAIN_START_PAUSED) # libvirt makes the NVRAM file at the first start
dom.destroy()
vm = wvmInstance(*self.args, None, uuid=dom.UUIDString())
source = vm.get_nvram()
uuid = vm.clone_instance(
{"name": P + "clone-uefi-copy", "disk-vda": P + "clone-uefi-copy-a.qcow2", "disk_owner_uid": 0, "disk_owner_gid": 0}
)
clone = self.conn.lookupByUUIDString(uuid)
path = ElementTree.fromstring(clone.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).findtext("os/nvram")
self.assertEqual(path, os.path.join(os.path.dirname(source), P + "clone-uefi-copy_VARS.fd"))
with vm._nvram_pool() as pool:
copy = pool.storageVolLookupByName(os.path.basename(path))
self.assertEqual(copy.info()[1], pool.storageVolLookupByName(os.path.basename(source)).info()[1])
clone.createWithFlags(libvirt.VIR_DOMAIN_START_PAUSED) # qemu opens the copy
self.assertEqual(
ElementTree.fromstring(clone.XMLDesc(0)).findtext("os/nvram"), path, "libvirt replaced the copy"
)
clone.destroy()
def test_clone_of_a_stopped_vm(self):
_, vm = self.source("clone-ok")
uuid = vm.clone_instance(self.clone_data("clone-ok-copy"))
clone = self.conn.lookupByUUIDString(uuid)
self.assertEqual(clone.name(), P + "clone-ok-copy")
self.assertTrue({P + "clone-ok-copy-a.qcow2", P + "clone-ok-copy-b.qcow2"} <= self.pool_volumes())

View file

@ -0,0 +1,198 @@
"""Live checks that a failed VM creation leaves no volumes behind.
Runs only with TEST_LIBVIRT_HOST set (see instances/tests/livetest.py).
"""
import os
import unittest
import libvirt
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from lxml import etree
from vrtManager.connection import connection_manager
from . import livetest
P = livetest.PREFIX
class LiveCreateTestCase(TestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.compute_args = dict(
hostname=os.environ["TEST_LIBVIRT_HOST"],
login=os.environ.get("TEST_LIBVIRT_LOGIN", ""),
password=os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
type=int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.compute_args.values())
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def setUp(self):
self.compute = Compute.objects.create(name="live-create", details="test", **self.compute_args)
admin = get_user_model().objects.create_superuser("create_admin", "c@example.com", "pw")
self.client.force_login(admin)
self.client.raise_request_exception = False
def tearDown(self):
livetest.cleanup(self.conn)
def create(self, name, **overrides):
data = {
"name": P + name,
"firmware": "BIOS",
"vcpu": 1,
"vcpu_mode": "host-model",
"memory": 128,
"hdd_size": 1,
"storage": livetest.POOL,
"mac": "52:54:00:aa:03:01",
"networks": "default",
"nwfilter": "",
"net_model": "virtio",
"cache_mode": "none",
"video": "vga",
"listener_addr": "0.0.0.0",
"console_pass": "",
"add_cdrom": "None",
"add_input": "None",
"create": True,
}
data.update(overrides)
return self.client.post(
reverse("instances:create_instance", args=[self.compute.id, "x86_64", "q35"]), data
)
def volumes(self):
pool = self.conn.storagePoolLookupByName(livetest.POOL)
pool.refresh(0)
return set(pool.listVolumes())
def domain_exists(self, name):
try:
self.conn.lookupByName(name)
return True
except libvirt.libvirtError:
return False
def assert_nothing_left(self, name, response):
self.assertLess(response.status_code, 500)
self.assertEqual(self.volumes(), set(), "a volume was left behind")
self.assertFalse(self.domain_exists(P + name))
def test_invalid_cache_mode_allocates_nothing(self):
self.assert_nothing_left("cr-cache", self.create("cr-cache", cache_mode="bogus"))
def test_malformed_uefi_firmware_allocates_nothing(self):
self.assert_nothing_left("cr-uefi", self.create("cr-uefi", firmware="UEFI"))
def test_rejected_definition_removes_the_new_disk(self):
self.assert_nothing_left("cr-define", self.create("cr-define", video="no-such-model"))
def test_successful_creation(self):
response = self.create("cr-ok")
self.assertEqual(response.status_code, 302)
self.assertTrue(self.domain_exists(P + "cr-ok"))
self.assertEqual(len(self.volumes()), 1)
def test_offered_uefi_firmware_boots_on_q35(self):
page = self.client.get(reverse("instances:create_instance", args=[self.compute.id, "x86_64", "q35"]))
uefi = [f for f in page.context["firmwares"] if f.startswith("UEFI")]
self.assertTrue(uefi, "no UEFI firmware offered for q35")
self.create("cr-uefi-ok", firmware=uefi[0])
dom = self.conn.lookupByName(P + "cr-uefi-ok")
loader = etree.fromstring(dom.XMLDesc(0)).findtext("os/loader")
self.assertEqual(loader, uefi[0].split(":", 1)[1].strip())
# Listed by libvirt for q35, so the domain starts with it
caps = etree.fromstring(self.conn.getDomainCapabilities(None, "x86_64", "q35", "kvm"))
self.assertIn(loader, caps.xpath("os/loader/value/text()"))
dom.create()
self.assertTrue(dom.isActive())
def test_secure_boot_loader_on_q35_gets_secure_boot(self):
caps = etree.fromstring(self.conn.getDomainCapabilities(None, "x86_64", "q35", "kvm"))
secboot = [p for p in caps.xpath("os/loader/value/text()") if "secboot" in p and "OVMF_CODE" in p]
if not secboot:
self.skipTest("the host has no secure boot loader for q35")
self.create("cr-secboot", firmware=f"UEFI x86_64: {secboot[0]}")
dom = self.conn.lookupByName(P + "cr-secboot")
tree = etree.fromstring(dom.XMLDesc(0))
self.assertEqual(tree.find("os/loader").get("secure"), "yes")
self.assertEqual(tree.find("features/smm").get("state"), "on")
dom.create()
self.assertTrue(dom.isActive())
def test_every_offered_cdrom_bus_creates_a_vm_that_starts(self):
page = self.client.get(reverse("instances:create_instance", args=[self.compute.id, "x86_64", "q35"]))
buses = page.context["cdrom_buses"]
self.assertTrue(buses)
for i, bus in enumerate(buses):
with self.subTest(bus=bus):
self.create(f"cr-cd-{bus}", add_cdrom=bus, mac=f"52:54:00:aa:03:1{i}")
dom = self.conn.lookupByName(P + f"cr-cd-{bus}")
self.assertEqual(etree.fromstring(dom.XMLDesc(0)).xpath("devices/disk[@device='cdrom']/target/@bus"), [bus])
dom.create()
self.assertTrue(dom.isActive())
def test_input_device_keeps_the_machine_usb_controller(self):
self.create("cr-input", add_input="usb")
tree = etree.fromstring(self.conn.lookupByName(P + "cr-input").XMLDesc(0))
self.assertEqual(tree.xpath("devices/controller[@type='usb']/@model"), ["qemu-xhci"])
self.assertTrue(tree.xpath("devices/input[@type='tablet' and @bus='usb']"))
def test_networks_without_a_mac_of_their_own(self):
self.create("cr-macs", networks="default,default")
macs = etree.fromstring(self.conn.lookupByName(P + "cr-macs").XMLDesc(0)).xpath("devices/interface/mac/@address")
self.assertEqual(len(macs), 2)
self.assertEqual(macs[0], "52:54:00:aa:03:01")
def test_api_rejected_definition_removes_the_new_disk(self):
response = self.client.post(
f"/api/v1/computes/{self.compute.id}/instances/create/x86_64/q35/",
{
"name": P + "cr-api",
"vcpu": 1,
"vcpu_mode": "host-model",
"memory": 128,
"networks": "default",
"mac": "52:54:00:aa:03:02",
"nwfilter": "",
"storage": livetest.POOL,
"hdd_size": 1,
"cache_mode": "none",
"meta_prealloc": False,
"virtio": True,
"qemu_ga": False,
"console_pass": "",
"listener_addr": "0.0.0.0",
"video": "no-such-model",
"add_cdrom": "None",
"add_input": "None",
},
content_type="application/json",
)
self.assertEqual(response.status_code, 400, response.content)
self.assertEqual(self.volumes(), set(), "a volume was left behind")
self.assertFalse(self.domain_exists(P + "cr-api"))

View file

@ -0,0 +1,542 @@
"""Live tests for cases that lost disks or changed the wrong VM.
Each test asserts the safe behavior. Known unfixed cases are marked
expectedFailure; a fix turns them into unexpected successes, which fail
the run until the marker is removed. Runs only with
TEST_LIBVIRT_HOST set (see instances/tests/livetest.py).
"""
import os
import unittest
import libvirt
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from vrtManager.connection import connection_manager
from . import livetest
from instances.models import Instance
from instances.utils import refr
P = livetest.PREFIX
class LiveDataLossTestCase(TestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.compute_args = dict(
hostname=os.environ["TEST_LIBVIRT_HOST"],
login=os.environ.get("TEST_LIBVIRT_LOGIN", ""),
password=os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
type=int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.compute_args.values())
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
# Last: a failure above must not leave the class transaction open,
# which would lock the shared test database for later test classes.
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def setUp(self):
self.compute = Compute.objects.create(name="live-dataloss", details="test", **self.compute_args)
admin = get_user_model().objects.create_superuser("live_admin", "l@example.com", "pw")
self.client.force_login(admin)
self.client.raise_request_exception = False
def tearDown(self):
livetest.cleanup(self.conn)
# helpers
def vm(self, name, disks, uefi=False, extra_devices=""):
dom = livetest.define_vm(self.conn, P + name, disks, uefi=uefi, extra_devices=extra_devices)
refr(self.compute)
return dom, Instance.objects.get(compute=self.compute, uuid=dom.UUIDString())
def post(self, view, instance, data=None):
return self.client.post(
reverse(f"instances:{view}", args=[instance.id]),
data or {},
HTTP_REFERER=reverse("instances:instance", args=[instance.id]),
)
def disk_sources(self, dom, flags=0):
from lxml import etree
return {
d.find("target").get("dev"): d.find("source").get("file")
for d in etree.fromstring(dom.XMLDesc(flags)).findall("devices/disk")
}
def domain_exists(self, uuid):
try:
self.conn.lookupByUUIDString(uuid)
return True
except libvirt.libvirtError:
return False
# External snapshots
@unittest.expectedFailure
def test_revert_external_snapshot_keeps_disk_added_later(self):
base = livetest.create_volume(self.conn, P + "r03-a")
dom, inst = self.vm("r03-a", [base])
self.post("create_external_snapshot", inst, {"name": "snap"})
later = livetest.create_volume(self.conn, P + "r03-later")
dom.attachDeviceFlags(
f"<disk type='file' device='disk'><driver name='qemu' type='qcow2'/>"
f"<source file='{later}'/><target dev='vdb' bus='virtio'/></disk>",
libvirt.VIR_DOMAIN_AFFECT_CONFIG,
)
self.post("revert_external_snapshot", inst, {"name": "s1.snap", "date": "", "desc": ""})
self.assertTrue(livetest.volume_exists(self.conn, later), "revert deleted a disk the snapshot never had")
@unittest.expectedFailure
def test_delete_older_external_snapshot_keeps_newer_snapshot_files(self):
base = livetest.create_volume(self.conn, P + "r03-b")
dom, inst = self.vm("r03-b", [base])
self.post("create_external_snapshot", inst, {"name": "older"})
self.post("create_external_snapshot", inst, {"name": "newer"})
sources = set(self.disk_sources(dom).values())
self.post("delete_external_snapshot", inst, {"name": "s1.older"})
for path in sources:
self.assertTrue(livetest.volume_exists(self.conn, path), f"{path} was deleted")
self.assertIn("s1.newer", dom.snapshotListNames(0))
# Internal snapshots of UEFI VMs
def _uefi_internal_snapshot(self, running):
base = livetest.create_volume(self.conn, P + "r13")
dom, inst = self.vm("r13", [base], uefi=True)
if running:
dom.create()
os_before = self.os_xml(dom)
response = self.post("snapshot", inst, {"name": "snap"})
# Taken where libvirt supports it, otherwise refused with a message;
# never a server error and never a rewritten loader or NVRAM.
self.assertEqual(response.status_code, 302)
if dom.snapshotNum(0) == 0:
self.assertTrue(list(get_messages(response.wsgi_request)))
self.assertEqual(self.os_xml(dom), os_before)
def os_xml(self, dom):
from lxml import etree
return etree.tostring(etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).find("os"))
def test_uefi_internal_snapshot_of_a_stopped_vm(self):
self._uefi_internal_snapshot(running=False)
def test_uefi_internal_snapshot_of_a_running_vm(self):
self._uefi_internal_snapshot(running=True)
# Destroy
def test_destroy_keeps_a_volume_another_vm_uses(self):
shared = livetest.create_volume(self.conn, P + "r14-shared")
_, inst = self.vm("r14-a", [shared])
self.vm("r14-b", [shared])
response = self.post("destroy", inst, {"delete_disk": "1"})
self.assertEqual(response.status_code, 302)
self.assertTrue(livetest.volume_exists(self.conn, shared), "destroy deleted another VM's disk")
def _destroy_base_of_another_vms_overlay(self, running):
base = livetest.create_volume(self.conn, P + "r14-base")
pool = self.conn.storagePoolLookupByName(livetest.POOL)
overlay = pool.createXML(
f"<volume><name>{P}r14-overlay.qcow2</name><capacity unit='MiB'>64</capacity>"
f"<target><format type='qcow2'/></target><backingStore><path>{base}</path>"
"<format type='qcow2'/></backingStore></volume>",
0,
).path()
_, inst = self.vm("r14-base", [base])
dom_b, _ = self.vm("r14-overlay", [overlay])
if running:
dom_b.create()
response = self.post("destroy", inst, {"delete_disk": "1"})
self.assertEqual(response.status_code, 302)
self.assertTrue(livetest.volume_exists(self.conn, base), "deleted the backing file of another VM's disk")
def test_destroy_keeps_the_backing_file_of_a_stopped_vm(self):
self._destroy_base_of_another_vms_overlay(running=False)
def test_destroy_keeps_the_backing_file_of_a_running_vm(self):
self._destroy_base_of_another_vms_overlay(running=True)
def test_destroy_with_managed_save_removes_the_vm(self):
base = livetest.create_volume(self.conn, P + "r14-save")
dom, inst = self.vm("r14-save", [base])
dom.create()
dom.managedSave(0)
self.post("destroy", inst, {"delete_disk": "1"})
uuid = dom.UUIDString()
self.assertFalse(self.domain_exists(uuid), "VM is still defined")
self.assertFalse(Instance.objects.filter(uuid=uuid).exists())
def test_destroy_of_a_paused_vm_removes_it(self):
base = livetest.create_volume(self.conn, P + "r14-paused")
dom, inst = self.vm("r14-paused", [base])
dom.create()
dom.suspend()
self.post("destroy", inst)
self.assertFalse(self.domain_exists(dom.UUIDString()), "paused VM is still running")
def nvram_files(self):
"""The test VMs' files in libvirt's NVRAM directory, read through a
transient pool (libvirt lists files only as volumes)."""
pool = self.conn.storagePoolCreateXML(
f"<pool type='dir'><name>{P}nvram</name><target><path>/var/lib/libvirt/qemu/nvram</path></target></pool>", 0
)
try:
return {name for name in pool.listVolumes() if name.startswith(P)}
finally:
pool.destroy()
def _destroy_uefi_vm(self, data):
dom = self.conn.defineXML(
f"<domain type='kvm'><name>{P}r14-nvram</name><memory unit='MiB'>128</memory><vcpu>1</vcpu>"
"<os firmware='efi'><type arch='x86_64' machine='q35'>hvm</type></os>"
"<features><acpi/></features><devices/></domain>"
)
refr(self.compute)
inst = Instance.objects.get(compute=self.compute, uuid=dom.UUIDString())
dom.createWithFlags(libvirt.VIR_DOMAIN_START_PAUSED) # creates the NVRAM file
dom.destroy()
self.assertIn(f"{P}r14-nvram_VARS.fd", self.nvram_files())
self.post("destroy", inst, data)
self.assertFalse(self.domain_exists(dom.UUIDString()), "VM is still defined")
return f"{P}r14-nvram_VARS.fd" in self.nvram_files()
def test_destroy_deletes_the_nvram_when_asked(self):
self.assertFalse(self._destroy_uefi_vm({"delete_nvram": "1"}), "the NVRAM file is still there")
def test_destroy_keeps_the_nvram_otherwise(self):
try:
self.assertTrue(self._destroy_uefi_vm({}), "the NVRAM file was deleted")
finally:
pool = self.conn.storagePoolCreateXML(
f"<pool type='dir'><name>{P}nvram</name><target><path>/var/lib/libvirt/qemu/nvram</path></target></pool>", 0
)
try:
for name in pool.listVolumes():
if name.startswith(P):
pool.storageVolLookupByName(name).delete(0)
finally:
pool.destroy()
def test_destroy_of_an_overlay_keeps_its_base(self):
# The base may be a template other images grow from; only the VM's
# own top image goes, with the snapshot metadata.
base = livetest.create_volume(self.conn, P + "r14-chain-base")
pool = self.conn.storagePoolLookupByName(livetest.POOL)
overlay = pool.createXML(
f"<volume><name>{P}r14-chain.qcow2</name><capacity unit='MiB'>64</capacity>"
f"<target><format type='qcow2'/></target><backingStore><path>{base}</path>"
"<format type='qcow2'/></backingStore></volume>",
0,
).path()
dom, inst = self.vm("r14-chain", [overlay])
dom.snapshotCreateXML("<domainsnapshot><name>snap</name></domainsnapshot>", 0)
response = self.post("destroy", inst, {"delete_disk": "1"})
self.assertEqual(response.status_code, 302)
self.assertFalse(self.domain_exists(dom.UUIDString()), "VM is still defined")
self.assertFalse(livetest.volume_exists(self.conn, overlay), "the VM's own image is still there")
self.assertTrue(livetest.volume_exists(self.conn, base), "the base image was deleted")
# Delete a volume only after it is detached
def _delete_attached_volume(self, pause):
base = livetest.create_volume(self.conn, P + "s02")
data = livetest.create_volume(self.conn, P + "s02-data")
dom, inst = self.vm("s02", [base, data])
dom.create()
if pause:
dom.suspend()
response = self.post("delete_vol", inst, {"dev": "vdb"})
self.assertEqual(response.status_code, 302)
# The guest has no OS, so it never releases the disk: the live
# definition keeps vdb, and the volume must be kept with it.
self.assertIn("vdb", self.disk_sources(dom))
self.assertTrue(livetest.volume_exists(self.conn, data), "volume deleted while the VM still uses it")
def test_delete_volume_of_a_paused_vm(self):
self._delete_attached_volume(pause=True)
def test_delete_volume_of_a_running_vm_without_guest_ack(self):
self._delete_attached_volume(pause=False)
def test_delete_volume_another_vm_uses_is_refused(self):
base = livetest.create_volume(self.conn, P + "s02-own")
shared = livetest.create_volume(self.conn, P + "s02-shared")
_, inst = self.vm("s02-a", [base, shared])
self.vm("s02-b", [shared])
response = self.post("delete_vol", inst, {"dev": "vdb"})
self.assertEqual(response.status_code, 302)
self.assertTrue(livetest.volume_exists(self.conn, shared), "deleted another VM's disk")
# Operations follow the VM's UUID, not its name
def test_mutation_follows_uuid_after_names_are_swapped(self):
dom_a, inst_a = self.vm("r06-a", [])
dom_b, _ = self.vm("r06-b", [])
dom_a.rename(P + "r06-tmp", 0)
dom_b.rename(P + "r06-a", 0)
dom_a.rename(P + "r06-b", 0)
self.post("change_options", inst_a, {"title": "for-a", "description": ""})
self.assertIn("<title>for-a</title>", dom_a.XMLDesc(0))
self.assertNotIn("<title>for-a</title>", dom_b.XMLDesc(0))
def test_vm_replaced_under_the_same_name_is_not_touched(self):
dom_old, inst = self.vm("r06-c", [])
dom_old.undefine()
dom_new = livetest.define_vm(self.conn, P + "r06-c", [])
self.post("change_options", inst, {"title": "for-old", "description": ""})
self.assertNotIn("<title>for-old</title>", dom_new.XMLDesc(0))
# Edits of a running VM are pending until restart; the forms must show them
def test_pending_nic_change_is_shown_and_can_be_edited_again(self):
nic = "<interface type='network'><mac address='52:54:00:aa:05:01'/><source network='default'/></interface>"
dom, inst = self.vm("nic-pending", [], extra_devices=nic)
dom.create()
def change(old, new):
return self.post("change_network", inst, {
"net-old-mac-0": old, "net-mac-0": new, "net-source-0": "net:default", "net-model-0": "virtio",
})
change("52:54:00:aa:05:01", "52:54:00:aa:05:02")
page = self.client.get(reverse("instances:instance", args=[inst.id])).content.decode()
self.assertIn('name="net-old-mac-0" value="52:54:00:aa:05:02"', page)
change("52:54:00:aa:05:02", "52:54:00:aa:05:03")
self.assertIn("52:54:00:aa:05:03", dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE))
def test_pending_disk_change_is_shown_and_kept_by_the_next_edit(self):
from lxml import etree, html
dom, inst = self.vm("disk-pending", [livetest.create_volume(self.conn, P + "disk-pending")])
dom.create()
live = dom.XMLDesc(0)
def edit_form():
page = self.client.get(reverse("instances:instance", args=[inst.id])).content
action = reverse("instances:edit_volume", args=[inst.id])
(form,) = html.fromstring(page).xpath("//form[@action=$a][.//input[@name='dev'][@value='vda']]", a=action)
return {**dict(form.form_values()), "edit_volume": ""} # what the browser posts
self.post("edit_volume", inst, {**edit_form(), "vol_cache": "none"})
form = edit_form()
self.assertEqual(form["vol_cache"], "none")
self.post("edit_volume", inst, {**form, "vol_serial": "wvc-serial"})
disk = etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).find("devices/disk")
self.assertEqual((disk.find("driver").get("cache"), disk.findtext("serial")), ("none", "wvc-serial"))
self.assertEqual(dom.XMLDesc(0), live)
def test_pending_options_and_cpu_changes_are_shown_and_kept_by_the_next_edit(self):
from lxml import etree, html
dom, inst = self.vm("options-pending", [])
dom.create()
live = dom.XMLDesc(0)
def form(view):
page = self.client.get(reverse("instances:instance", args=[inst.id])).content
(form,) = html.fromstring(page).xpath("//form[@action=$a]", a=reverse(f"instances:{view}", args=[inst.id]))
return dict(form.form_values()) # what the form would post
# the buttons are disabled while it runs; a direct post is pending
self.post("change_options", inst, {**form("change_options"), "title": "wvc-title"})
self.post("resizevm_cpu", inst, {**form("resizevm_cpu"), "vcpu": "2"})
options, cpu = form("change_options"), form("resizevm_cpu")
self.assertEqual((options["title"], cpu["vcpu"]), ("wvc-title", "2"))
self.post("change_options", inst, {**options, "description": "wvc-description"})
self.post("resizevm_cpu", inst, {**cpu, "cur_vcpu": "1"})
tree = etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE))
self.assertEqual((tree.findtext("title"), tree.findtext("description"), tree.findtext("vcpu")),
("wvc-title", "wvc-description", "2"))
self.assertEqual(dom.XMLDesc(0), live)
def test_pending_boot_order_and_video_are_shown_and_a_live_only_choice_changes_nothing(self):
from lxml import etree, html
nic = "<interface type='network'><mac address='52:54:00:aa:05:21'/><source network='default'/></interface>"
graphics = "<graphics type='vnc' autoport='yes' listen='127.0.0.1'/>"
dom, inst = self.vm("boot-pending", [livetest.create_volume(self.conn, P + "boot-pending")],
extra_devices=nic + graphics)
self.post("set_bootmenu", inst)
dom.create()
# pending order; a NIC the running VM has but its next start will not
self.post("set_bootorder", inst, {"bootorder": "network:52:54:00:aa:05:21,disk:vda"})
dom.attachDeviceFlags(nic.replace("05:21", "05:22"), libvirt.VIR_DOMAIN_AFFECT_LIVE)
persistent = lambda: etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)) # noqa: E731
video = "virtio" if persistent().find("devices/video/model").get("type") != "virtio" else "vga"
self.post("set_video_model", inst, {"video_model": video})
live = dom.XMLDesc(0)
page = html.fromstring(self.client.get(reverse("instances:instance", args=[inst.id])).content)
(boot,) = page.xpath("//form[@action=$a]", a=reverse("instances:set_bootorder", args=[inst.id]))
self.assertEqual(boot.xpath(".//input[@type='checkbox']/@value"), ["disk:vda", "network:52:54:00:aa:05:21"])
self.assertEqual(page.xpath("//select[@name='video_model']/option[@selected]/@value"), [video])
self.post("set_bootorder", inst, {"bootorder": "network:52:54:00:aa:05:22,disk:vda"})
tree = persistent()
self.assertEqual(tree.xpath("devices/interface/boot/@order"), ["1"])
self.assertEqual(tree.xpath("devices/disk[target/@dev='vda']/boot/@order"), ["2"])
self.assertEqual(dom.XMLDesc(0), live)
def test_a_new_disk_does_not_take_a_name_pending_in_the_persistent_definition(self):
from lxml import html
disks = [livetest.create_volume(self.conn, P + n) for n in ("name-a", "name-b")]
dom, inst = self.vm("disk-name", disks, extra_devices="<controller type='scsi' model='virtio-scsi'/>")
dom.create()
# vdb becomes sata: renamed sda in the persistent definition only
page = self.client.get(reverse("instances:instance", args=[inst.id])).content
action = reverse("instances:edit_volume", args=[inst.id])
(form,) = html.fromstring(page).xpath("//form[@action=$a][.//input[@name='dev'][@value='vdb']]", a=action)
self.post("edit_volume", inst, {**dict(form.form_values()), "edit_volume": "", "vol_bus": "sata"})
self.assertEqual(self.disk_sources(dom, libvirt.VIR_DOMAIN_XML_INACTIVE).get("sda"), disks[1])
# scsi shares the sd names: the new disk must not be sda
self.post("add_new_vol", inst, {"storage": livetest.POOL, "name": P + "name-new", "format": "qcow2",
"size": "1", "bus": "scsi", "cache": "default"})
new = f"{livetest.POOL_PATH}/{P}name-new.qcow2"
self.assertEqual(self.disk_sources(dom).get("sdb"), new)
self.assertEqual(self.disk_sources(dom, libvirt.VIR_DOMAIN_XML_INACTIVE).get("sdb"), new)
dom.destroy()
dom.create()
self.assertEqual(self.disk_sources(dom), {"vda": disks[0], "sda": disks[1], "sdb": new})
def test_a_sata_disk_cannot_be_added_to_a_running_vm_and_nothing_changes(self):
dom, inst = self.vm("sata-hotplug", [livetest.create_volume(self.conn, P + "sata-a")])
dom.create()
before = (self.disk_sources(dom), self.disk_sources(dom, libvirt.VIR_DOMAIN_XML_INACTIVE))
response = self.post("add_new_vol", inst, {"storage": livetest.POOL, "name": P + "sata-new", "format": "qcow2",
"size": "1", "bus": "sata", "cache": "default"})
self.assertEqual(response.status_code, 500)
self.assertEqual((self.disk_sources(dom), self.disk_sources(dom, libvirt.VIR_DOMAIN_XML_INACTIVE)), before)
# the new volume stays in the pool: it is never deleted unasked
self.assertIn(P + "sata-new.qcow2", self.conn.storagePoolLookupByName(livetest.POOL).listVolumes())
def test_an_attach_that_conflicts_with_a_pending_device_changes_neither_definition(self):
controllers = "<controller type='scsi' index='0' model='virtio-scsi'/><controller type='virtio-serial'/>"
def disk(path):
return (f"<disk type='file' device='disk'><driver name='qemu' type='qcow2'/><source file='{path}'/>"
"<target dev='sda' bus='scsi'/></disk>")
agent = "<channel type='unix'><target type='virtio' name='org.qemu.guest_agent.0'/></channel>"
cases = (
("disk", lambda n: disk(livetest.create_volume(self.conn, P + n + "-pending")),
lambda vm, n: vm.attach_disk("sda", livetest.create_volume(self.conn, P + n + "-new"),
target_bus="scsi", format_type="qcow2")),
("agent", lambda n: agent, lambda vm, n: vm.add_guest_agent()),
)
both = (0, libvirt.VIR_DOMAIN_XML_INACTIVE)
for paused in (False, True):
for case, pending, attach in cases:
with self.subTest(case=case, paused=paused):
name = f"attach-{case}-{int(paused)}" # own volumes: a leftover plug must not lock them
dom, inst = self.vm(name, [], extra_devices=controllers)
dom.create()
dom.attachDeviceFlags(pending(name), libvirt.VIR_DOMAIN_AFFECT_CONFIG) # pending: persistent only
if paused:
dom.suspend()
before = [dom.XMLDesc(flags) for flags in both]
with self.assertRaises(libvirt.libvirtError):
attach(inst.proxy, name)
self.assertEqual([dom.XMLDesc(flags) for flags in both], before)
def test_a_nic_without_a_mac_gets_the_same_one_in_both_definitions(self):
from lxml import etree
nic = "<interface type='network'><mac address='52:54:00:aa:18:09'/><source network='default'/></interface>"
dom, inst = self.vm("nic-mac", [], extra_devices=nic)
dom.create()
self.post("add_network", inst, {"add-net-network": "net:default", "add-net-mac": "", "add-net-model": "virtio"})
def macs(flags):
return set(etree.fromstring(dom.XMLDesc(flags)).xpath("devices/interface/mac/@address")) - {"52:54:00:aa:18:09"}
self.assertEqual(len(macs(0)), 1)
self.assertEqual(macs(libvirt.VIR_DOMAIN_XML_INACTIVE), macs(0))
def test_an_empty_scsi_cdrom_reaches_both_definitions_of_a_running_vm(self):
from lxml import etree
dom, inst = self.vm("cdrom-scsi", [], extra_devices="<controller type='scsi' index='0' model='virtio-scsi'/>")
dom.create()
self.post("add_cdrom", inst, {"bus": "scsi"})
for flags in (0, libvirt.VIR_DOMAIN_XML_INACTIVE):
tree = etree.fromstring(dom.XMLDesc(flags))
self.assertEqual(tree.xpath("devices/disk[@device='cdrom']/target/@dev"), ["sda"])
def test_pending_qos_change_is_shown_and_kept_by_the_next_edit(self):
from lxml import etree, html
mac = "52:54:00:aa:05:11"
nic = (f"<interface type='network'><mac address='{mac}'/><source network='default'/>"
"<bandwidth><inbound average='500' peak='0' burst='0'/></bandwidth></interface>")
dom, inst = self.vm("qos-pending", [], extra_devices=nic)
dom.create()
live = dom.XMLDesc(0)
def row():
page = html.fromstring(self.client.get(reverse("instances:instance", args=[inst.id])).content)
(label,) = page.xpath("//label[@class='col-form-label'][contains(., 'Inbound')]")
fields = label.xpath("ancestor::tr[1]//input[@name]") # the browser posts the row's inputs
return {f.get("name"): f.get("value") for f in fields}
self.post("set_qos", inst, {**row(), "qos_average": "1000"})
form = row()
self.assertEqual(form["qos_average"], "1000")
self.post("set_qos", inst, {**form, "qos_peak": "600"})
inbound = etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).find("devices/interface/bandwidth/inbound")
self.assertEqual((inbound.get("average"), inbound.get("peak")), ("1000", "600"))
self.assertEqual(dom.XMLDesc(0), live)

View file

@ -0,0 +1,86 @@
"""Live checks that a disk grows while its VM runs or is paused.
QEMU holds a running domain's image, so the size goes through blockResize;
the guest and the volume must both see it, and the persistent definition
stays as it was. Runs only with TEST_LIBVIRT_HOST set (see instances/tests/livetest.py).
"""
import os
import unittest
import libvirt
from django.test import SimpleTestCase
from vrtManager.connection import connection_manager
from vrtManager.instance import wvmInstance
from . import livetest
P = livetest.PREFIX
PERSISTENT = libvirt.VIR_DOMAIN_XML_INACTIVE | libvirt.VIR_DOMAIN_XML_SECURE
class LiveDiskResizeTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.args = (
os.environ["TEST_LIBVIRT_HOST"],
os.environ.get("TEST_LIBVIRT_LOGIN", ""),
os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.args)
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def tearDown(self):
livetest.cleanup(self.conn)
def vm(self, name, fmt):
pool = self.conn.storagePoolLookupByName(livetest.POOL)
vol = pool.createXML(
f"<volume><name>{P}{name}.{fmt}</name><capacity unit='MiB'>64</capacity>"
f"<target><format type='{fmt}'/></target></volume>",
0,
)
dom = self.conn.defineXML(
f"<domain type='kvm'><name>{P}{name}</name><memory unit='MiB'>128</memory><vcpu>1</vcpu>"
"<os><type arch='x86_64' machine='q35'>hvm</type></os><features><acpi/></features><devices>"
f"<disk type='file' device='disk'><driver name='qemu' type='{fmt}'/>"
f"<source file='{vol.path()}'/><target dev='vda' bus='virtio'/></disk></devices></domain>"
)
return dom, vol, wvmInstance(*self.args, f"{P}{name}")
def test_a_disk_grows_while_the_vm_runs_or_is_paused(self):
new_size = 96 << 20
for state in ("running", "paused"):
for fmt in ("qcow2", "raw"):
with self.subTest(state=state, fmt=fmt):
try:
dom, vol, vm = self.vm(f"resize-{state}-{fmt}", fmt)
dom.create()
if state == "paused":
dom.suspend()
before = dom.XMLDesc(PERSISTENT)
disk = vm.get_disk_devices()[0]
vm.resize_disk([{"path": disk["path"], "size_new": new_size}])
self.assertEqual(dom.blockInfo(disk["path"])[0], new_size, "the guest's disk")
self.assertEqual(vol.info()[1], new_size, "the volume")
self.assertEqual(dom.XMLDesc(PERSISTENT), before)
self.assertEqual(dom.state()[0], libvirt.VIR_DOMAIN_PAUSED if state == "paused" else libvirt.VIR_DOMAIN_RUNNING)
finally:
livetest.cleanup(self.conn)

View file

@ -0,0 +1,401 @@
"""Live tests that need a running guest OS with qemu-guest-agent.
Set TEST_LIBVIRT_GUEST_IMAGE to the path of an installed Linux image on the
test host: a BIOS-bootable qcow2 volume in a storage pool other than wvc-test,
with qemu-guest-agent enabled.
The tests boot wvc-test VMs from qcow2 overlays in the test pool, so the
image itself is only read. They are skipped while a running VM uses the
image, since its content would change under the overlays. Runs only with TEST_LIBVIRT_HOST set as well (see
instances/tests/livetest.py).
"""
import json
import os
import time
import unittest
import libvirt
import libvirt_qemu
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from lxml import etree
from vrtManager.connection import connection_manager
from . import livetest
from instances.models import Instance
from instances.utils import refr
P = livetest.PREFIX
BOOT_TIMEOUT = 300
def wait_for(check, timeout, interval=2):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
if check():
return True
time.sleep(interval)
return check()
class LiveGuestTestCase(TestCase):
@classmethod
def setUpClass(cls):
cls.image = os.environ.get("TEST_LIBVIRT_GUEST_IMAGE")
if not livetest.enabled() or not cls.image:
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST and TEST_LIBVIRT_GUEST_IMAGE to run the guest tests")
cls.compute_args = dict(
hostname=os.environ["TEST_LIBVIRT_HOST"],
login=os.environ.get("TEST_LIBVIRT_LOGIN", ""),
password=os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
type=int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.compute_args.values())
try:
image = cls.conn.storageVolLookupByPath(cls.image)
except libvirt.libvirtError as err:
raise RuntimeError(f"TEST_LIBVIRT_GUEST_IMAGE must be a volume in a storage pool: {err}") from err
if image.storagePoolLookupByVolume().name() == livetest.POOL:
raise RuntimeError(f"TEST_LIBVIRT_GUEST_IMAGE must not be in the {livetest.POOL} pool, which the tests empty")
cls.image_bytes = image.info()[1] # overlays get the image's exact virtual size
for dom in cls.conn.listAllDomains(libvirt.VIR_CONNECT_LIST_DOMAINS_ACTIVE):
if cls.image in dom.XMLDesc(0):
raise unittest.SkipTest(f"{dom.name()} is running from {cls.image}")
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def setUp(self):
self.compute = Compute.objects.create(name="live-guest", details="test", **self.compute_args)
admin = get_user_model().objects.create_superuser("guest_admin", "g@example.com", "pw")
self.client.force_login(admin)
self.client.raise_request_exception = False
def tearDown(self):
livetest.cleanup(self.conn)
def boot(self, name, data_disk=False):
"""A running copy of the guest image; returns the domain and its Instance."""
dom, _ = self.define(name, data_disk)
return self.start(dom)
def define(self, name, data_disk=False):
"""A stopped copy of the guest image; returns the domain and its Instance."""
pool = self.conn.storagePoolLookupByName(livetest.POOL)
root = pool.createXML(
f"<volume><name>{P}{name}.qcow2</name><capacity unit='bytes'>{self.image_bytes}</capacity>"
"<target><format type='qcow2'/></target>"
f"<backingStore><path>{self.image}</path><format type='qcow2'/></backingStore></volume>",
0,
).path()
data = livetest.create_volume(self.conn, P + name + "-data") if data_disk else None
disks = f"<disk type='file' device='disk'><driver name='qemu' type='qcow2'/><source file='{root}'/>" \
"<target dev='vda' bus='virtio'/><serial>wvc-root</serial></disk>"
if data:
disks += f"<disk type='file' device='disk'><driver name='qemu' type='qcow2'/><source file='{data}'/>" \
"<target dev='vdb' bus='virtio'/><serial>wvc-data</serial></disk>"
# No PCI controllers: libvirt then adds the root ports the devices need
# plus one free port, which the NIC hotplug test uses. With explicit
# controllers it adds no free port.
dom = self.conn.defineXML(f"""
<domain type='kvm'>
<name>{P}{name}</name>
<memory unit='MiB'>2048</memory>
<vcpu placement='static' current='1'>2</vcpu>
<vcpus>
<vcpu id='0' enabled='yes' hotpluggable='no' order='1'/>
<vcpu id='1' enabled='no' hotpluggable='yes'/>
</vcpus>
<os><type arch='x86_64' machine='q35'>hvm</type><boot dev='hd'/></os>
<features><acpi/><apic/></features>
<cpu mode='host-model'/>
<devices>
{disks}
<interface type='network'><source network='default'/><model type='virtio'/></interface>
<channel type='unix'><target type='virtio' name='org.qemu.guest_agent.0'/></channel>
<serial type='pty'/>
</devices>
</domain>""")
refr(self.compute)
return dom, Instance.objects.get(compute=self.compute, uuid=dom.UUIDString())
def start(self, dom):
if not dom.isActive():
dom.create()
self.wait_agent(dom)
return dom, Instance.objects.get(compute=self.compute, uuid=dom.UUIDString())
def wait_agent(self, dom):
self.assertTrue(wait_for(lambda: self.agent(dom, "guest-ping") is not None, BOOT_TIMEOUT), "guest agent never answered")
def agent(self, dom, command):
try:
return json.loads(libvirt_qemu.qemuAgentCommand(dom, json.dumps({"execute": command}), 5, 0))["return"]
except libvirt.libvirtError:
return None
def guest_view(self, dom):
"""Hardware as the guest agent reports it."""
blocks = self.agent(dom, "guest-get-memory-blocks") or []
block_size = (self.agent(dom, "guest-get-memory-block-info") or {}).get("size", 0)
disks = sorted(
# SATA disks report their serial as QEMU_HARDDISK_<serial>
((d["address"].get("serial") or "").removeprefix("QEMU_HARDDISK_"), d["address"]["bus-type"])
for d in self.agent(dom, "guest-get-disks") or []
if not d["partition"] and "address" in d
)
# Emulated NICs have QEMU's 52:54: prefix; guest-made interfaces (docker0,
# veth) do not, and a bridge repeats its member's MAC.
macs = {
i["hardware-address"]
for i in self.agent(dom, "guest-network-get-interfaces") or []
if i.get("hardware-address", "").startswith("52:54:")
}
return {
"vcpus": sum(1 for cpu in self.agent(dom, "guest-get-vcpus") or [] if cpu["online"]),
"memory_mib": block_size * sum(1 for b in blocks if b["online"]) >> 20,
"disks": disks,
"macs": macs,
}
def config_view(self, dom):
"""The same hardware in the persistent definition."""
tree = etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE))
vcpu = tree.find("vcpu")
return {
"vcpus": int(vcpu.get("current", vcpu.text)),
"memory_mib": int(tree.findtext("memory")) >> 10,
"disks": sorted(
(d.findtext("serial") or "", d.find("target").get("bus")) for d in tree.xpath("devices/disk[@device='disk']")
),
"macs": set(tree.xpath("devices/interface/mac/@address")),
}
def assert_guest_matches_config(self, dom, timeout=60):
"""The guest sees what the persistent definition says (hotplugged devices may take a moment)."""
wait_for(lambda: self.guest_view(dom) == self.config_view(dom), timeout)
self.assertEqual(self.guest_view(dom), self.config_view(dom))
def post(self, view, instance, data=None):
response = self.client.post(
reverse(f"instances:{view}", args=[instance.id]),
data or {},
HTTP_REFERER=reverse("instances:instance", args=[instance.id]),
)
self.assertEqual(response.status_code, 302, f"{view} failed")
return response
def live(self, dom):
return etree.fromstring(dom.XMLDesc(0))
def test_deleting_a_disk_the_guest_releases_deletes_the_volume(self):
dom, inst = self.boot("gdel", data_disk=True)
data = self.live(dom).xpath("devices/disk[target/@dev='vdb']/source/@file")[0]
response = self.post("delete_vol", inst, {"dev": "vdb"})
self.assertEqual(response.status_code, 302)
self.assertFalse(self.live(dom).xpath("devices/disk[target/@dev='vdb']"), "still attached")
self.assertFalse(
etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).xpath("devices/disk[target/@dev='vdb']")
)
self.assertFalse(livetest.volume_exists(self.conn, data), "volume kept although the guest released it")
def test_detaching_a_disk_removes_it_from_the_running_guest(self):
dom, inst = self.boot("gdet", data_disk=True)
data = self.live(dom).xpath("devices/disk[target/@dev='vdb']/source/@file")[0]
response = self.post("detach_vol", inst, {"dev": "vdb"})
self.assertEqual(response.status_code, 302)
self.assertTrue(wait_for(lambda: not self.live(dom).xpath("devices/disk[target/@dev='vdb']"), 30))
self.assertTrue(livetest.volume_exists(self.conn, data), "detach must keep the volume")
def test_nic_hotplug_and_unplug(self):
dom, inst = self.boot("gnic")
mac = "52:54:00:aa:03:01"
self.post("add_network", inst, {"add-net-mac": mac, "add-net-network": "net:default", "add-net-model": "virtio"})
self.assertTrue(self.live(dom).xpath("devices/interface[mac/@address=$m]", m=mac), "NIC not attached")
self.assertTrue(
wait_for(lambda: any(i["hardware-address"] == mac for i in self.agent(dom, "guest-network-get-interfaces") or []), 60),
"guest does not see the new NIC",
)
self.post("delete_network", inst, {"delete_network": mac})
self.assertTrue(wait_for(lambda: not self.live(dom).xpath("devices/interface[mac/@address=$m]", m=mac), 30))
self.assertFalse(
etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).xpath("devices/interface[mac/@address=$m]", m=mac)
)
def test_vcpu_hotplug_reaches_the_guest(self):
dom, inst = self.boot("gcpu")
def online():
return sum(1 for cpu in self.agent(dom, "guest-get-vcpus") or [] if cpu["online"])
self.assertEqual(online(), 1)
self.post("set_vcpu", inst, {"id": "1", "set_vcpu": "True"})
self.assertTrue(wait_for(lambda: online() == 2, 60), "guest did not bring the new vCPU online")
def test_agent_reports_the_guest_os_and_nic(self):
dom, inst = self.boot("gagent")
response = self.client.get(reverse("instances:osinfo", args=[inst.id]))
self.assertEqual(response.status_code, 200)
# One field from each agent call osinfo() merges: osinfo, timezone, host name
self.assertLessEqual({"kernel-release", "zone", "host-name"}, set(response.json()))
# The NIC is matched by MAC in the agent's report. Whether the guest has
# an address depends on its network configuration, not on WebVirtCloud.
mac = self.live(dom).xpath("devices/interface/mac/@address")[0]
proxy = inst.proxy
proxy.refresh_interface_addresses()
self.assertIn(mac, [nic["hwaddr"] for nic in proxy._ip_cache["qemuga"].values()])
def test_poweroff_shuts_the_guest_down(self):
dom, inst = self.boot("goff")
# A guest that is still booting ignores or delays the request (seen:
# 20 s to over 3 min right after the agent came up). Let the boot
# finish, then press power off again if needed, as a user would.
time.sleep(60)
for _ in range(6):
self.assertEqual(self.post("poweroff", inst).status_code, 302)
if wait_for(lambda: not dom.isActive(), 30):
break
self.assertFalse(dom.isActive(), "guest did not shut down on ACPI")
# The guest sees the hardware WebVirtCloud configures
def test_guest_sees_the_configured_hardware(self):
dom, _ = self.boot("ghw", data_disk=True)
self.assert_guest_matches_config(dom)
def test_cpu_and_memory_resize_reach_the_guest_after_a_restart(self):
dom, inst = self.boot("gres")
self.post("force_off", inst)
self.assertFalse(dom.isActive(), "force off left the VM running")
self.post("resizevm_cpu", inst, {"vcpu": "2", "cur_vcpu": "2"})
self.post("resize_memory", inst, {"memory": "3072", "cur_memory": "3072"})
self.post("poweron", inst)
self.wait_agent(dom)
self.assert_guest_matches_config(dom)
self.assertEqual(self.guest_view(dom)["vcpus"], 2)
self.assertEqual(self.guest_view(dom)["memory_mib"], 3072)
def test_disk_changes_reach_the_guest(self):
dom, inst = self.boot("gdisk", data_disk=True)
data = self.live(dom).xpath("devices/disk[target/@dev='vdb']/source/@file")[0]
# Hotplugged at once
self.post("add_new_vol", inst, {"storage": livetest.POOL, "name": P + "gdisk-new", "size": "1", "format": "qcow2", "bus": "virtio"})
self.assertEqual(len(self.config_view(dom)["disks"]), 3, "disk was not added")
self.assert_guest_matches_config(dom)
# Persistent only: bus and serial change at the next start
self.post("edit_volume", inst, {
"edit_volume": "1", "dev": "vdb", "vol_path": data, "vol_bus": "sata",
"vol_serial": "wvc-edited", "vol_format": "qcow2",
})
self.assertNotIn(("wvc-edited", "sata"), self.guest_view(dom)["disks"])
self.post("powercycle", inst)
self.wait_agent(dom)
self.assert_guest_matches_config(dom)
self.assertIn(("wvc-edited", "sata"), self.guest_view(dom)["disks"])
def test_nic_mac_change_reaches_the_guest_after_a_restart(self):
dom, inst = self.boot("gmac")
old, new = self.live(dom).xpath("devices/interface/mac/@address")[0], "52:54:00:aa:05:01"
self.post("change_network", inst, {
"net-old-mac-0": old, "net-mac-0": new, "net-source-0": "net:default",
"net-model-0": "virtio", "net-nwfilter-0": "",
})
self.assertEqual(self.guest_view(dom)["macs"], {old}) # pending until the next start
self.post("powercycle", inst)
self.wait_agent(dom)
self.assert_guest_matches_config(dom)
self.assertEqual(self.guest_view(dom)["macs"], {new})
def test_clone_guest_sees_its_own_nic_and_disk(self):
source, inst = self.define("gsrc")
mac = "52:54:00:aa:06:01"
self.post("clone", inst, {"name": P + "gclone", "disk-vda": P + "gclone.qcow2", "clone-net-mac-0": mac})
clone = self.conn.lookupByName(P + "gclone")
self.start(clone)
self.assert_guest_matches_config(clone)
self.assertEqual(self.guest_view(clone)["macs"], {mac})
self.assertNotIn(
source.XMLDesc(0).split("<source file='")[1].split("'")[0],
clone.XMLDesc(0),
"the clone uses the source's disk",
)
# Power and state operations seen from the guest
def test_snapshot_revert_restores_the_running_guest(self):
dom, inst = self.boot("gsnap")
mac = "52:54:00:aa:07:01"
self.post("snapshot", inst, {"name": "before"})
self.assertEqual(dom.snapshotNum(0), 1, "snapshot was not taken")
self.post("add_network", inst, {"add-net-mac": mac, "add-net-network": "net:default", "add-net-model": "virtio"})
self.assertTrue(wait_for(lambda: mac in self.guest_view(dom)["macs"], 60), "guest does not see the new NIC")
self.post("revert_snapshot", inst, {"name": "before"})
self.wait_agent(dom)
self.assertTrue(dom.isActive(), "reverting a running snapshot left the VM stopped")
self.assertNotIn(mac, self.config_view(dom)["macs"])
self.assert_guest_matches_config(dom)
def test_suspend_and_resume(self):
dom, inst = self.boot("gsus")
self.post("suspend", inst)
self.assertEqual(dom.state()[0], libvirt.VIR_DOMAIN_PAUSED)
self.assertIsNone(self.agent(dom, "guest-ping"), "a paused guest answered")
self.post("resume", inst)
self.assertEqual(dom.state()[0], libvirt.VIR_DOMAIN_RUNNING)
self.wait_agent(dom)
self.assert_guest_matches_config(dom)
def test_a_paused_guest_gets_its_new_memory_once_resumed(self):
dom, inst = self.boot("gmem")
def balloon_mib():
return dom.memoryStats().get("actual", 0) >> 10
def config_mib(tag):
return int(etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_INACTIVE)).findtext(tag)) >> 10
for cur in (1536, 2048): # down, then back up to the maximum
self.post("suspend", inst)
# the posted maximum is ignored: an active VM keeps its own
self.post("resize_memory", inst, {"memory": "4096", "cur_memory": str(cur)})
self.assertEqual(dom.state()[0], libvirt.VIR_DOMAIN_PAUSED)
self.assertEqual((config_mib("currentMemory"), config_mib("memory")), (cur, 2048))
self.post("resume", inst)
self.assertTrue(wait_for(lambda: balloon_mib() == cur, 60), f"balloon at {balloon_mib()} MiB, not {cur}")
self.wait_agent(dom)

View file

@ -0,0 +1,96 @@
"""Live checks for ISO mount/unmount. Runs only with TEST_LIBVIRT_HOST set."""
import os
import unittest
import libvirt
from django.test import SimpleTestCase
from lxml import etree
from vrtManager.connection import connection_manager
from vrtManager.instance import wvmInstance
from . import livetest
P = livetest.PREFIX
CDROMS = (
"<disk type='file' device='cdrom'><driver name='qemu' type='raw'/><target dev='sda' bus='sata'/><readonly/></disk>"
"<disk type='file' device='cdrom'><driver name='qemu' type='raw'/><target dev='sdb' bus='sata'/><readonly/></disk>"
"<graphics type='vnc' autoport='yes' passwd='keep1234'/>"
)
PERSISTENT = libvirt.VIR_DOMAIN_XML_INACTIVE | libvirt.VIR_DOMAIN_XML_SECURE
class LiveIsoTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.args = (
os.environ["TEST_LIBVIRT_HOST"],
os.environ.get("TEST_LIBVIRT_LOGIN", ""),
os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.args)
livetest.cleanup(cls.conn)
pool = livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
cls.iso = pool.createXML(
f"<volume><name>{P}media.iso</name><capacity unit='MiB'>1</capacity><target><format type='raw'/></target></volume>", 0
).path()
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def tearDown(self):
for dom in self.conn.listAllDomains():
if dom.name().startswith(P):
if dom.isActive():
dom.destroy()
dom.undefineFlags(livetest.UNDEFINE_FLAGS)
def vm(self, state):
dom = livetest.define_vm(self.conn, P + "iso-" + state, [], extra_devices=CDROMS)
if state in ("running", "paused"):
dom.create()
if state == "paused":
dom.suspend()
return dom, wvmInstance(*self.args, None, uuid=dom.UUIDString())
def media(self, dom, flags):
tree = etree.fromstring(dom.XMLDesc(flags))
return {d.find("target").get("dev"): d.xpath("string(source/@file)") for d in tree.xpath("devices/disk[@device='cdrom']")}
def test_mount_and_unmount_in_every_state(self):
for state in ("stopped", "running", "paused"):
with self.subTest(state):
dom, vm = self.vm(state)
try:
vm.mount_iso("sdb", os.path.basename(self.iso))
views = [PERSISTENT] + ([0] if dom.isActive() else [])
for flags in views:
self.assertEqual(self.media(dom, flags), {"sda": "", "sdb": self.iso}, f"flags={flags}")
self.assertIn("keep1234", dom.XMLDesc(PERSISTENT))
vm.umount_iso("sdb", self.iso)
for flags in views:
self.assertEqual(self.media(dom, flags), {"sda": "", "sdb": ""}, f"flags={flags}")
self.assertIn("keep1234", dom.XMLDesc(PERSISTENT))
finally:
self.tearDown()
def test_unknown_iso_or_device_changes_nothing(self):
dom, vm = self.vm("running")
before = (dom.XMLDesc(0), dom.XMLDesc(PERSISTENT))
for dev, image in (("sdb", "no-such.iso"), ("sdz", os.path.basename(self.iso))):
with self.subTest(dev=dev, image=image):
with self.assertRaises(libvirt.libvirtError):
vm.mount_iso(dev, image)
self.assertEqual((dom.XMLDesc(0), dom.XMLDesc(PERSISTENT)), before)

View file

@ -0,0 +1,112 @@
"""Live checks that persistent edits keep secrets and pending changes.
Every edit that redefines the domain must start from the persistent
definition with secrets (VIR_DOMAIN_XML_INACTIVE | VIR_DOMAIN_XML_SECURE).
Runs only with TEST_LIBVIRT_HOST set (see instances/tests/livetest.py).
"""
import os
import unittest
import libvirt
from django.test import SimpleTestCase
from lxml import etree
from vrtManager.connection import connection_manager
from vrtManager.instance import wvmInstance
from . import livetest
P = livetest.PREFIX
MAC = "52:54:00:aa:01:01"
DEVICES = (
f"<interface type='network'><mac address='{MAC}'/><source network='default'/><model type='virtio'/></interface>"
"<graphics type='vnc' autoport='yes' passwd='keep1234'/>"
"<video><model type='vga' primary='yes'/></video>"
)
PERSISTENT = libvirt.VIR_DOMAIN_XML_INACTIVE | libvirt.VIR_DOMAIN_XML_SECURE
# name -> (edit, allowed while running)
EDITS = {
"set_bootmenu": (lambda vm: vm.set_bootmenu(1), True),
"set_bootorder": (lambda vm: vm.set_bootorder({0: {"type": "disk", "dev": "vda"}}), True),
"set_vcpu_hotplug": (lambda vm: vm.set_vcpu_hotplug(True, 1), False),
"set_console_keymap": (lambda vm: vm.set_console_keymap("de"), True),
"set_console_listener_addr": (lambda vm: vm.set_console_listener_addr("127.0.0.1"), True),
"set_video_model": (lambda vm: vm.set_video_model("virtio"), True),
"resize_cpu": (lambda vm: vm.resize_cpu("1", "2"), True),
"resize_mem": (lambda vm: vm.resize_mem(128, 160), False),
"resize_disk": (lambda vm: vm.resize_disk([{"path": vm.get_disk_devices()[0]["path"], "size_new": 96 << 20}]), True),
"set_options": (lambda vm: vm.set_options({"title": "edited"}), True),
"set_qos": (lambda vm: vm.set_qos(MAC, "inbound", 100, 200, 300), True),
"unset_qos": (lambda vm: vm.unset_qos(MAC, "inbound"), True),
}
class LivePersistentEditTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.args = (
os.environ["TEST_LIBVIRT_HOST"],
os.environ.get("TEST_LIBVIRT_LOGIN", ""),
os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.args)
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def tearDown(self):
livetest.cleanup(self.conn)
def vm(self, name):
disk = livetest.create_volume(self.conn, P + name)
dom = livetest.define_vm(self.conn, P + name, [disk], extra_devices=DEVICES)
return dom, wvmInstance(*self.args, None, uuid=dom.UUIDString())
def persistent(self, dom):
return etree.fromstring(dom.XMLDesc(PERSISTENT))
def test_edits_of_a_stopped_vm_keep_the_vnc_password(self):
for name, (edit, _) in EDITS.items():
with self.subTest(name):
try:
dom, vm = self.vm("xml-stopped")
edit(vm)
self.assertEqual(self.persistent(dom).xpath("string(devices/graphics/@passwd)"), "keep1234")
finally:
livetest.cleanup(self.conn)
def test_edits_of_a_running_vm_keep_pending_changes(self):
for name, (edit, while_running) in EDITS.items():
if not while_running:
continue
with self.subTest(name):
try:
dom, vm = self.vm("xml-running")
dom.create()
# A pending change: only the persistent definition has 192 MiB.
tree = self.persistent(dom)
tree.find("memory").text = str(192 * 1024)
tree.find("currentMemory").text = str(192 * 1024)
self.conn.defineXML(etree.tostring(tree).decode())
edit(vm)
after = self.persistent(dom)
self.assertEqual(after.findtext("memory"), str(192 * 1024), "pending memory change lost")
self.assertEqual(after.xpath("string(devices/graphics/@passwd)"), "keep1234")
finally:
livetest.cleanup(self.conn)

View file

@ -0,0 +1,294 @@
"""Live checks that each domain edit does what it says and nothing else.
For every edit the persistent definition (inactive, with secrets) is read
before and after. The edit must show its effect, and once the nodes it is
allowed to touch are removed from both sides, the rest of the definition
must be identical: unknown elements, secrets and pending changes survive.
On a running VM, edits of the persistent definition must leave the live
one alone. Runs only with TEST_LIBVIRT_HOST set (see instances/tests/livetest.py).
"""
import os
import unittest
import libvirt
from django.test import SimpleTestCase
from lxml import etree
from vrtManager.connection import connection_manager
from vrtManager.instance import wvmInstance
from . import livetest
P = livetest.PREFIX
MAC = "52:54:00:aa:02:01"
PERSISTENT = libvirt.VIR_DOMAIN_XML_INACTIVE | libvirt.VIR_DOMAIN_XML_SECURE
PARSER = etree.XMLParser(remove_blank_text=True)
def domain_xml(name, disk, iso):
"""A VM with elements WebVirtCloud does not manage, which edits must keep."""
return f"""
<domain type='kvm'>
<name>{name}</name>
<title>original title</title>
<metadata><app:info xmlns:app='http://example.com/wvc-test'>keep-metadata</app:info></metadata>
<memory unit='MiB'>128</memory>
<currentMemory unit='MiB'>128</currentMemory>
<memoryBacking><nosharepages/></memoryBacking>
<vcpu placement='static'>1</vcpu>
<cputune><shares>2048</shares></cputune>
<os><type arch='x86_64' machine='q35'>hvm</type><boot dev='hd'/></os>
<features><acpi/><apic/></features>
<on_crash>restart</on_crash>
<devices>
<disk type='file' device='disk'>
<driver name='qemu' type='qcow2' cache='none'/>
<source file='{disk}'/>
<target dev='vda' bus='virtio'/>
<serial>keep-serial</serial>
<iotune><total_bytes_sec>10485760</total_bytes_sec></iotune>
</disk>
<disk type='file' device='cdrom'>
<driver name='qemu' type='raw'/>
<source file='{iso}'/>
<target dev='sda' bus='sata'/>
<readonly/>
</disk>
<interface type='network'>
<mac address='{MAC}'/>
<source network='default'/>
<model type='virtio'/>
<bandwidth><outbound average='1000' peak='2000' burst='1024'/></bandwidth>
</interface>
<graphics type='vnc' autoport='yes' passwd='keep1234' keymap='en-us'>
<listen type='address' address='0.0.0.0'/>
</graphics>
<video><model type='vga' primary='yes'/></video>
<serial type='pty'><target port='0'/></serial>
<rng model='virtio'><backend model='random'>/dev/urandom</backend></rng>
<watchdog model='i6300esb' action='reset'/>
<controller type='virtio-serial'/> <!-- add_guest_agent hotplugs a channel -->
</devices>
</domain>"""
def first(tree, path):
found = tree.xpath(path)
return found[0] if found else None
# name -> (edit, check of the new persistent tree, paths the edit may change,
# allowed while running, changes the running VM too)
EDITS = {
"set_bootmenu": (
lambda vm: vm.set_bootmenu(1),
lambda t: first(t, "os/bootmenu/@enable") == "yes",
["os/bootmenu"], True, False,
),
"set_bootorder": (
lambda vm: vm.set_bootorder({0: {"type": "disk", "dev": "vda"}}),
lambda t: first(t, "devices/disk[target/@dev='vda']/boot/@order") == "1" and not t.xpath("os/boot"),
["os/boot", "devices/*/boot"], True, False,
),
"set_vcpu_hotplug": (
lambda vm: vm.set_vcpu_hotplug(True, 1),
lambda t: bool(t.xpath("vcpus/vcpu")),
["vcpus"], False, False,
),
"set_console_keymap": (
lambda vm: vm.set_console_keymap("de"),
lambda t: first(t, "devices/graphics/@keymap") == "de",
["devices/graphics/@keymap"], True, False,
),
"set_console_listener_addr": (
lambda vm: vm.set_console_listener_addr("127.0.0.1"),
lambda t: first(t, "devices/graphics/listen/@address") == "127.0.0.1",
["devices/graphics/@listen", "devices/graphics/listen/@address"], True, False,
),
"set_console_passwd": (
lambda vm: vm.set_console_passwd("new12345"),
lambda t: first(t, "devices/graphics/@passwd") == "new12345",
["devices/graphics/@passwd"], True, False,
),
"set_video_model": (
lambda vm: vm.set_video_model("virtio"),
lambda t: first(t, "devices/video/model/@type") == "virtio",
["devices/video"], True, False,
),
"resize_cpu": (
lambda vm: vm.resize_cpu("1", "2"),
lambda t: t.findtext("vcpu") == "2" and first(t, "vcpu/@current") == "1",
["vcpu"], True, False,
),
"resize_mem": (
lambda vm: vm.resize_mem(128, 160),
lambda t: t.findtext("memory") == str(160 * 1024),
["memory", "currentMemory"], False, False,
),
"set_options": (
lambda vm: vm.set_options({"title": "new title", "description": "new description"}),
lambda t: t.findtext("title") == "new title" and t.findtext("description") == "new description",
["title", "description"], True, False,
),
"set_qos": (
lambda vm: vm.set_qos(MAC, "inbound", 100, 200, 300),
lambda t: first(t, "devices/interface/bandwidth/inbound/@average") == "100"
and first(t, "devices/interface/bandwidth/outbound/@average") == "1000",
["devices/interface/bandwidth/inbound"], True, False,
),
"unset_qos": (
lambda vm: vm.unset_qos(MAC, "outbound"),
lambda t: not t.xpath("devices/interface/bandwidth/outbound"),
["devices/interface/bandwidth"], True, False,
),
"umount_iso": (
lambda vm: vm.umount_iso("sda"),
lambda t: not t.xpath("devices/disk[target/@dev='sda']/source/@file"),
["devices/disk[target/@dev='sda']/source"], True, True,
),
"set_link_state": (
lambda vm: vm.set_link_state(MAC, "down"),
lambda t: first(t, "devices/interface/link/@state") == "down",
["devices/interface/link"], True, True,
),
"change_network (same MAC, new model)": (
lambda vm: vm.change_network(MAC, MAC, "default", "net", "e1000e", ""),
lambda t: first(t, "devices/interface/model/@type") == "e1000e"
and first(t, "devices/interface/bandwidth/outbound/@average") == "1000",
["devices/interface/model"], True, False,
),
"add_network": (
lambda vm: vm.add_network("52:54:00:aa:02:09", "default", "net", "virtio"),
lambda t: len(t.xpath("devices/interface")) == 2,
["devices/interface[mac/@address='52:54:00:aa:02:09']"], True, True,
),
"delete_network": (
lambda vm: vm.delete_network(MAC),
lambda t: not t.xpath("devices/interface"),
["devices/interface"], True, True,
),
"attach_disk": (
lambda vm: vm.attach_disk("vdc", livetest.create_volume(vm.wvm, P + "fx-extra"), target_bus="virtio", format_type="qcow2"),
lambda t: bool(t.xpath("devices/disk[target/@dev='vdc']")),
["devices/disk[target/@dev='vdc']"], True, True,
),
"add_guest_agent": (
lambda vm: vm.add_guest_agent(),
lambda t: bool(t.xpath("devices/channel/target[@name='org.qemu.guest_agent.0']")),
["devices/channel[target/@name='org.qemu.guest_agent.0']"], True, True,
),
"edit_disk (cache mode)": (
lambda vm: vm.edit_disk("vda", vm.get_disk_devices(config=True)[0]["path"], False, False, "virtio",
"keep-serial", "qcow2", "writeback", None, None, None),
lambda t: first(t, "devices/disk[target/@dev='vda']/driver/@cache") == "writeback",
["devices/disk[target/@dev='vda']/driver/@cache"], True, False,
),
}
def canonical(tree, paths):
tree = etree.fromstring(etree.tostring(tree), PARSER)
for path in paths:
for node in tree.xpath(path):
if isinstance(node, etree._ElementUnicodeResult):
node.getparent().attrib.pop(node.attrname, None)
else:
node.getparent().remove(node)
return etree.tostring(tree, method="c14n").decode()
class LiveXmlEffectsTestCase(SimpleTestCase):
@classmethod
def setUpClass(cls):
if not livetest.enabled():
raise unittest.SkipTest("Set TEST_LIBVIRT_HOST to run the live libvirt tests")
cls.args = (
os.environ["TEST_LIBVIRT_HOST"],
os.environ.get("TEST_LIBVIRT_LOGIN", ""),
os.environ.get("TEST_LIBVIRT_PASSWORD", ""),
int(os.environ.get("TEST_LIBVIRT_TYPE", 4)),
)
cls.conn = connection_manager.get_connection(*cls.args)
livetest.cleanup(cls.conn)
livetest.ensure_pool(cls.conn)
cls.inventory = livetest.inventory(cls.conn)
super().setUpClass()
@classmethod
def tearDownClass(cls):
try:
livetest.remove_pool(cls.conn)
finally:
super().tearDownClass()
if livetest.inventory(cls.conn) != cls.inventory:
raise AssertionError("Live tests changed objects outside the test namespace")
def vm(self, running, paused=False):
disk = livetest.create_volume(self.conn, P + "fx")
iso = self.conn.storagePoolLookupByName(livetest.POOL).createXML(
f"<volume><name>{P}fx.iso</name><capacity unit='MiB'>1</capacity><target><format type='raw'/></target></volume>", 0
).path()
dom = self.conn.defineXML(domain_xml(P + "fx", disk, iso))
if running:
dom.create()
# A pending change only in the persistent definition
tree = self.persistent(dom)
tree.find("on_crash").text = "destroy"
self.conn.defineXML(etree.tostring(tree).decode())
if paused:
dom.suspend()
return dom, wvmInstance(*self.args, None, uuid=dom.UUIDString())
def persistent(self, dom):
return etree.fromstring(dom.XMLDesc(PERSISTENT), PARSER)
def live(self, dom):
return etree.fromstring(dom.XMLDesc(libvirt.VIR_DOMAIN_XML_SECURE), PARSER)
def check(self, running, paused=False):
for name, (edit, effect, touched, allowed_running, changes_live) in EDITS.items():
if running and not allowed_running:
continue
with self.subTest(name):
try:
dom, vm = self.vm(running, paused)
before, live_before = self.persistent(dom), dom.isActive() and self.live(dom)
edit(vm)
after = self.persistent(dom)
self.assertTrue(effect(after), "edit had no effect")
self.assertEqual(canonical(after, touched), canonical(before, touched), "unrelated change")
# An unplug completes only when the guest acknowledges it; these
# VMs have no OS (test_live_guest covers it with a real guest).
if running and changes_live and name != "delete_network":
self.assertTrue(effect(self.live(dom)), "edit did not reach the running VM")
if running and not changes_live:
self.assertEqual(
canonical(self.live(dom), ["devices/graphics/@port"]),
canonical(live_before, ["devices/graphics/@port"]),
"persistent-only edit changed the running VM",
)
finally:
livetest.cleanup(self.conn)
def test_edits_of_a_stopped_vm(self):
self.check(running=False)
def test_edits_of_a_running_vm(self):
self.check(running=True)
def test_edits_of_a_paused_vm(self):
self.check(running=True, paused=True)
def test_enabling_vcpu_hotplug_keeps_the_current_vcpus(self):
try:
dom, vm = self.vm(running=False)
vm.resize_cpu("2", "4")
vm.set_vcpu_hotplug(True)
after = self.persistent(dom)
self.assertEqual((after.findtext("vcpu"), first(after, "vcpu/@current")), ("4", "2"))
self.assertEqual(after.xpath("vcpus/vcpu/@enabled"), ["yes", "yes", "no", "no"])
self.assertEqual(after.xpath("vcpus/vcpu/@hotpluggable"), ["no", "yes", "yes", "yes"])
dom.create()
self.assertEqual(dom.vcpusFlags(libvirt.VIR_DOMAIN_AFFECT_LIVE), 2)
finally:
livetest.cleanup(self.conn)

View file

@ -0,0 +1,64 @@
"""The migrate form ticks auto converge for a running VM, and the API uses
the same default: it only slows a VM that the migration cannot keep up with."""
import re
from unittest.mock import patch
import libvirt
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from rest_framework.test import APIClient
DOMAIN = """<domain type='test'><name>migrate-form-vm</name><memory unit='MiB'>128</memory><vcpu>1</vcpu>
<os><type arch='i686'>hvm</type></os></domain>"""
class MigrateFormTests(TestCase):
def setUp(self):
self.conn = libvirt.open("test:///default")
self.addCleanup(self.conn.close)
self.domain = self.conn.defineXML(DOMAIN)
self.addCleanup(self.remove_domain)
self.compute = Compute.objects.create(name="mf", hostname="localhost", login="", password="", type=4)
self.other = Compute.objects.create(name="mf-other", hostname="198.51.100.30", login="", password="", type=4)
self.vm = Instance.objects.create(compute=self.compute, name=self.domain.name(), uuid=self.domain.UUIDString())
for target, value in (("get_machine_types", ["pc"]), ("get_nwfilters", [])):
patcher = patch(f"vrtManager.connection.wvmConnect.{target}", return_value=value)
patcher.start()
self.addCleanup(patcher.stop)
self.admin = get_user_model().objects.create_superuser("mf-admin", "mf@example.com", "pw")
def remove_domain(self):
if self.domain.isActive():
self.domain.destroy()
self.domain.undefine()
def autoconverge_input(self):
self.client.force_login(self.admin)
with patch("vrtManager.connection.connection_manager.get_connection", return_value=self.conn):
page = self.client.get(reverse("instances:instance", args=[self.vm.id])).content.decode()
return re.search(r'<input[^>]*id="autoconverge"[^>]*>', page).group(0)
def test_auto_converge_is_ticked_for_a_running_vm(self):
self.domain.create()
self.assertIn("checked", self.autoconverge_input())
def test_a_shut_off_vm_has_no_auto_converge(self):
field = self.autoconverge_input()
self.assertIn("disabled", field)
self.assertNotIn("checked", field)
def test_the_api_uses_auto_converge_unless_told_otherwise(self):
api = APIClient()
api.force_authenticate(self.admin)
request = {"instance": self.vm.id, "target_compute": self.other.id, "live": True, "offline": False}
with patch("instances.api.viewsets.migrate_instance", return_value="live") as migrate:
for encoding in ("json", "multipart"):
api.post("/api/v1/migrate/", request, format=encoding)
api.post("/api/v1/migrate/", {**request, "autoconverge": False}, format="json")
api.post("/api/v1/migrate/", {**request, "unsafe": True}, format="json")
self.assertEqual([c.kwargs["autoconverge"] for c in migrate.call_args_list], [True, True, False, True])
self.assertEqual([c.kwargs["unsafe"] for c in migrate.call_args_list], [False, False, False, True])

View file

@ -0,0 +1,97 @@
"""What migrate_instance does around the migration itself: it checks the
destination with the app's connection, re-reads the VM under the compute
locks, and records a finished migration even when autostart fails."""
import re
from pathlib import Path
from unittest.mock import MagicMock, patch
from accounts.models import UserInstance
from computes.models import Compute
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db import DatabaseError
from django.test import TestCase
from logs.models import Logs
from instances.models import Instance
from instances.utils import MIGRATION_TIME_LIMIT, migrate_instance
from vrtManager import util
class MigrationBookkeepingTests(TestCase):
def setUp(self):
self.admin = get_user_model().objects.create_superuser("mb-admin", "mb@example.com", "pw")
self.source = Compute.objects.create(name="mb-src", hostname="198.51.100.8", login="root", password="", type=2)
self.dest = Compute.objects.create(name="mb-dst", hostname="198.51.100.9", login="root", password="", type=2)
self.vm = Instance.objects.create(compute=self.source, name="vm", uuid="u-mb", is_template=True)
def migrate(self, vm=None, up=True, autostart=False, autostart_error=None):
proxy = MagicMock()
proxy.get_autostart.return_value = autostart
with patch.object(Compute, "status", up), \
patch("instances.utils.wvmInstances") as instances, \
patch("instances.utils.wvmInstance") as instance, \
patch.object(Instance, "proxy", proxy):
instances.return_value.moveto.return_value = "live"
if autostart_error:
instance.return_value.set_autostart.side_effect = autostart_error
self.moveto = instances.return_value.moveto
self.set_autostart = instance.return_value.set_autostart
return migrate_instance(self.dest, vm or self.vm, self.admin, live=True)
def test_a_destination_the_app_cannot_connect_to_is_refused(self):
with self.assertRaisesRegex(util.OperationError, "mb-dst is not reachable"):
self.migrate(up=False)
self.moveto.assert_not_called()
def test_a_vm_moved_meanwhile_is_not_migrated_again(self):
stale = Instance.objects.get(id=self.vm.id)
Instance.objects.filter(id=self.vm.id).update(compute=self.dest) # another request moved it
with self.assertRaisesRegex(util.OperationError, "no longer on mb-src"):
self.migrate(vm=stale)
self.moveto.assert_not_called()
Instance.objects.filter(id=self.vm.id).delete() # merged into a record on the destination
with self.assertRaisesRegex(util.OperationError, "no longer on mb-src"):
self.migrate(vm=stale)
self.moveto.assert_not_called()
def test_autostart_is_read_from_libvirt_and_restored_on_the_destination(self):
self.vm.__dict__["autostart"] = False # an earlier, cached read
self.migrate(autostart=True)
self.set_autostart.assert_called_once_with(1)
def test_a_failed_autostart_does_not_stop_the_records(self):
self.migrate(autostart=True, autostart_error=util.OperationError("no autostart"))
self.assertEqual(Instance.objects.get(id=self.vm.id).compute, self.dest)
self.assertEqual(
Logs.objects.get().message,
"Instance is migrated(live) to 198.51.100.9; setting its autostart there failed: no autostart",
)
def test_a_failed_record_is_logged_as_such(self):
with patch.object(Instance, "save", side_effect=DatabaseError("locked")), \
self.assertRaises(DatabaseError):
self.migrate()
self.assertEqual(
Logs.objects.get().message,
"Instance is migrated(live) to 198.51.100.9, but recording it failed: locked",
)
def test_a_record_the_destination_already_has_keeps_template_and_owners(self):
owner = get_user_model().objects.create_user("mb-owner")
UserInstance.objects.create(user=owner, instance=self.vm, is_change=True)
found = Instance.objects.create(compute=self.dest, name="vm", uuid="u-mb") # listed there meanwhile
old_id = self.vm.id
self.migrate()
self.assertFalse(Instance.objects.filter(id=old_id).exists())
found.refresh_from_db()
self.assertTrue(found.is_template)
self.assertEqual(UserInstance.objects.get(user=owner).instance_id, found.id)
def test_a_migration_is_cancelled_before_the_web_server_ends_the_request(self):
self.migrate()
self.assertEqual(self.moveto.call_args.kwargs["timeout"], MIGRATION_TIME_LIMIT)
gunicorn = (Path(settings.BASE_DIR) / "gunicorn.conf.py").read_text()
request_timeout = int(re.search(r"^timeout = (\d+)", gunicorn, re.M).group(1))
self.assertLess(MIGRATION_TIME_LIMIT, request_timeout - 30) # time to answer and log

View file

@ -0,0 +1,116 @@
"""A migration is logged where it runs (migrate_instance), for the VM page
and the API alike: the mode it used on success, the error on failure."""
from unittest.mock import MagicMock, patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from libvirt import libvirtError
from logs.models import Logs
from rest_framework.test import APIClient
from instances.models import Instance
from instances.utils import migrate_instance
from vrtManager import util
class MigrationLogTests(TestCase):
def setUp(self):
self.admin = get_user_model().objects.create_superuser("ml-admin", "ml@example.com", "pw")
self.source = Compute.objects.create(name="ml-src", hostname="198.51.100.8", login="root", password="", type=2)
self.dest = Compute.objects.create(name="ml-dst", hostname="198.51.100.9", login="root", password="", type=2)
self.vm = Instance.objects.create(compute=self.source, name="vm", uuid="u-ml")
def migrate(self, outcome, nvram=None, remove_nvram=True, **request):
self.proxy = MagicMock()
self.proxy.get_autostart.return_value = False
self.proxy.get_nvram.return_value = nvram
if isinstance(remove_nvram, Exception):
self.proxy.remove_nvram.side_effect = remove_nvram
else:
self.proxy.remove_nvram.return_value = remove_nvram
with patch.object(Compute, "status", True), \
patch("instances.utils.wvmInstances") as instances, \
patch("instances.utils.wvmInstance"), \
patch.object(Instance, "proxy", self.proxy), \
patch.object(Instance, "autostart", False):
if isinstance(outcome, Exception):
instances.return_value.moveto.side_effect = outcome
else:
instances.return_value.moveto.return_value = outcome
return migrate_instance(self.dest, self.vm, self.admin, **request)
def test_the_nvram_file_left_on_the_source_is_removed(self):
self.migrate("live", nvram="/var/lib/libvirt/qemu/nvram/vm_VARS.fd", live=True)
path, destination = self.proxy.remove_nvram.call_args[0]
self.assertEqual(path, "/var/lib/libvirt/qemu/nvram/vm_VARS.fd")
self.assertIsNotNone(destination)
self.assertEqual(Logs.objects.get().message, "Instance is migrated(live) to 198.51.100.9")
def test_a_vm_without_nvram_removes_nothing(self):
self.migrate("live", live=True)
self.assertFalse(self.proxy.remove_nvram.called)
def test_a_failed_nvram_removal_is_logged_but_the_migration_stands(self):
self.migrate("live", nvram="/var/lib/libvirt/qemu/nvram/vm_VARS.fd",
remove_nvram=libvirtError("cannot delete"), live=True)
self.assertEqual(
Logs.objects.get().message,
"Instance is migrated(live) to 198.51.100.9; removing its NVRAM file "
"/var/lib/libvirt/qemu/nvram/vm_VARS.fd on the source failed: cannot delete",
)
self.vm.refresh_from_db()
self.assertEqual(self.vm.compute, self.dest)
def test_any_nvram_removal_error_still_records_the_migration(self):
self.migrate("live", nvram="/var/lib/libvirt/qemu/nvram/vm_VARS.fd",
remove_nvram=AttributeError("unexpected"), live=True)
self.vm.refresh_from_db()
self.assertEqual(self.vm.compute, self.dest)
self.assertIn("on the source failed: unexpected", Logs.objects.get().message)
def test_a_failed_migration_removes_nothing(self):
with self.assertRaises(util.OperationError):
self.migrate(util.OperationError("no"), nvram="/var/lib/libvirt/qemu/nvram/vm_VARS.fd", live=True)
self.assertFalse(self.proxy.remove_nvram.called)
def test_success_names_the_mode_used(self):
self.migrate("non-live, compressed", live=False, compress=True)
log = Logs.objects.get()
self.assertEqual(log.message, "Instance is migrated(non-live, compressed) to 198.51.100.9")
self.assertEqual((log.user, log.host, log.instance), ("ml-admin", "198.51.100.8", "vm"))
def test_success_names_the_migration_address(self):
self.dest.migration_address = "203.0.113.9"
self.migrate("live", live=True)
self.assertEqual(Logs.objects.get().message, "Instance is migrated(live) to 198.51.100.9 via 203.0.113.9")
self.vm.compute = self.source
self.vm.save()
self.dest.migration_address = "198.51.100.9" # the host name itself
self.migrate("live", live=True)
self.assertEqual(Logs.objects.latest("id").message, "Instance is migrated(live) to 198.51.100.9")
def test_failure_is_logged_and_raised(self):
with self.assertRaisesRegex(util.OperationError, "A shut-off VM cannot be migrated live"):
self.migrate(util.OperationError("A shut-off VM cannot be migrated live"), live=True)
self.assertEqual(
Logs.objects.get().message,
"Instance migration to 198.51.100.9 failed: A shut-off VM cannot be migrated live",
)
def test_the_page_and_the_api_log_once_through_migrate_instance(self):
self.client.force_login(self.admin)
api = APIClient()
api.force_authenticate(self.admin)
with patch("instances.views.utils.migrate_instance", return_value="live") as page_migrate:
self.client.post(reverse("instances:migrate", args=[self.vm.id]),
{"compute_id": self.dest.id, "live_migrate": "true"})
with patch("instances.api.viewsets.migrate_instance", return_value="live") as api_migrate:
response = api.post("/api/v1/migrate/", {"instance": self.vm.id, "target_compute": self.dest.id,
"live": True, "offline": False}, format="json")
self.assertEqual(page_migrate.call_count, 1)
self.assertEqual(api_migrate.call_count, 1)
self.assertFalse(Logs.objects.exists()) # migrate_instance logs; it is patched here
self.assertEqual(response.json(), {"status": "instance is migrated (live)"})

View file

@ -0,0 +1,95 @@
"""A mutation view whose form field the UI always sends must not crash with a
500 when the field is missing (a malformed or direct request): it reports the
problem and returns to the VM page without changing anything."""
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from computes.models import Compute
from instances.models import Instance
from logs.models import Logs
class MissingFieldTestCase(TestCase):
def setUp(self):
self.client.force_login(get_user_model().objects.create_superuser("mf", "mf@example.com", "pw"))
self.compute = Compute.objects.create(name="mf-c", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=self.compute, name="mf-vm", uuid="11111111-2222-3333-4444-555555555555"
)
def post(self, name, data=None):
with patch("instances.models.wvmInstance"), patch("instances.views.wvmInterface"):
return self.client.post(
reverse(f"instances:{name}", args=[self.instance.id]),
data or {},
HTTP_REFERER=f"http://testserver/instances/{self.instance.id}/",
)
def assert_reported(self, response):
self.assertEqual(response.status_code, 302)
levels = [m.level_tag for m in get_messages(response.wsgi_request)]
self.assertIn("error", levels, "an error message is shown")
self.assertFalse(Logs.objects.exists(), "nothing is logged as done")
def test_add_network_without_a_network(self):
self.assert_reported(self.post("add_network"))
def test_add_network_mutation_is_not_attempted(self):
with patch("instances.models.wvmInstance") as wvm, patch("instances.views.wvmInterface"):
self.client.post(reverse("instances:add_network", args=[self.instance.id]), {})
wvm.return_value.add_network.assert_not_called()
def test_set_qos_without_a_mac(self):
self.assert_reported(self.post("set_qos", {"qos_direction": "inbound"}))
def test_set_qos_without_a_direction(self):
self.assert_reported(self.post("set_qos", {"net-mac-0": "52:54:00:00:00:01"}))
def test_resize_cpu_without_a_value(self):
self.assert_reported(self.post("resizevm_cpu"))
def test_resize_cpu_with_a_non_numeric_value(self):
self.assert_reported(self.post("resizevm_cpu", {"vcpu": "lots", "cur_vcpu": "1"}))
def test_resize_memory_without_a_value(self):
self.assert_reported(self.post("resize_memory"))
def test_resize_cpu_with_a_unicode_digit(self):
# "²".isdigit() is True but int("²") raises; the guard must still hold
self.assert_reported(self.post("resizevm_cpu", {"vcpu": "²", "cur_vcpu": "1"}))
def test_resize_memory_with_a_unicode_digit(self):
self.assert_reported(self.post("resize_memory", {"memory": "512", "cur_memory_custom": "²"}))
def test_set_qos_with_non_numeric_rate(self):
self.assert_reported(self.post("set_qos", {"qos_direction": "inbound", "net-mac-0": "52:54:00:00:00:01", "qos_average": "fast"}))
def test_set_qos_with_an_invalid_direction(self):
self.assert_reported(self.post("set_qos", {"qos_direction": "sideways", "net-mac-0": "52:54:00:00:00:01"}))
def test_unset_qos_without_a_direction(self):
self.assert_reported(self.post("unset_qos", {"net-mac": "52:54:00:00:00:01"}))
def test_add_public_key_without_a_key(self):
response = self.post("add_public_key")
self.assertEqual(response.status_code, 302)
levels = [m.level_tag for m in get_messages(response.wsgi_request)]
self.assertIn("error", levels)
def test_mutations_are_not_attempted(self):
cases = {
"set_qos": ({"qos_direction": "inbound"}, "set_qos"),
"unset_qos": ({"net-mac": "52:54:00:00:00:01"}, "unset_qos"),
"resizevm_cpu": ({}, "resize_cpu"),
"resize_memory": ({}, "resize_mem"),
}
for view, (data, method) in cases.items():
with self.subTest(view=view):
with patch("instances.models.wvmInstance") as wvm, patch("instances.views.wvmInterface"):
self.client.post(reverse(f"instances:{view}", args=[self.instance.id]), data)
getattr(wvm.return_value, method).assert_not_called()

View file

@ -0,0 +1,143 @@
"""
A VM operation waits for the VM's compute lock while a migration holds it.
When the migration moves the VM to another compute meanwhile, the waiting
operation holds the old compute's lock, not the new one's: it must not run
on the new host but answer "busy, retry", and the retry locks the right
compute.
"""
from contextlib import contextmanager
from unittest.mock import PropertyMock, patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from computes.models import Compute
from instances.models import Instance
class MovedWhileWaitingTestCase(TestCase):
def setUp(self):
self.admin = get_user_model().objects.create_superuser("moved_admin", "m@example.com", "x")
self.source = Compute.objects.create(name="src", hostname="192.0.2.1", login="root", password="", type=1)
self.target = Compute.objects.create(name="dst", hostname="192.0.2.2", login="root", password="", type=1)
self.vm = Instance.objects.create(
compute=self.source, name="moved-vm", uuid="eeeeeeee-ffff-0000-1111-222222222222"
)
self.client.force_login(self.admin)
def poweroff(self, lock):
with patch("instances.views.libvirt_instance_lock", lock), patch(
"instances.models.wvmInstance"
) as wvm, patch.object(Compute, "status", new_callable=PropertyMock, return_value=True):
response = self.client.post(reverse("instances:poweroff", args=[self.vm.id]))
return response, wvm.return_value.shutdown.called
def test_a_vm_moved_while_the_request_waited_is_not_touched(self):
@contextmanager
def lock_after_a_migration(instance, timeout=15.0):
# the migration that held the lock moved the VM before releasing it
Instance.objects.filter(pk=instance.pk).update(compute=self.target)
yield
response, touched = self.poweroff(lock_after_a_migration)
self.assertFalse(touched)
self.assertEqual(response.status_code, 302)
messages = [str(m) for m in response.wsgi_request._messages]
self.assertIn("Instance operation is busy. Please retry.", messages)
def test_a_vm_that_stayed_is_changed(self):
@contextmanager
def plain_lock(instance, timeout=15.0):
yield
response, touched = self.poweroff(plain_lock)
self.assertTrue(touched)
def test_destroy_of_a_vm_moved_while_it_waited_is_not_run(self):
# destroy holds the whole compute; the migration moved the VM before
# releasing it
@contextmanager
def compute_lock_after_a_migration(compute, timeout=15.0, *, shared=False):
Instance.objects.filter(pk=self.vm.pk).update(compute=self.target)
yield
with patch("instances.views.libvirt_compute_lock", compute_lock_after_a_migration), patch(
"instances.models.wvmInstance"
) as wvm, patch.object(Compute, "status", new_callable=PropertyMock, return_value=True):
response = self.client.post(reverse("instances:destroy", args=[self.vm.id]), {"delete_disk": "on"})
self.assertFalse(wvm.return_value.delete.called)
self.assertTrue(Instance.objects.filter(pk=self.vm.pk).exists())
messages = [str(m) for m in response.wsgi_request._messages]
self.assertIn("Instance operation is busy. Please retry.", messages)
def clone(self, user, change):
@contextmanager
def compute_lock_meanwhile(compute, timeout=15.0, *, shared=False):
change()
yield
self.client.force_login(user)
with patch("instances.views.libvirt_compute_lock", compute_lock_meanwhile), patch(
"instances.models.wvmInstance"
) as wvm, patch.object(Compute, "status", new_callable=PropertyMock, return_value=True), patch(
"instances.views.utils.check_user_quota", return_value="" # not what this tests
):
wvm.return_value.get_disk_devices.return_value = []
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.get_memory.return_value = 512
response = self.client.post(reverse("instances:clone", args=[self.vm.id]), {"name": "moved-clone"})
return response, wvm.return_value.clone_instance.called
def test_a_clone_of_a_vm_moved_while_it_waited_is_not_made(self):
from accounts.models import UserInstance
from django.contrib.auth.models import Permission
# an owner who may clone it (a superuser would also choose MACs)
owner = get_user_model().objects.create_user("clone_owner", password="x")
owner.user_permissions.add(Permission.objects.get(codename="clone_instances"))
UserInstance.objects.create(instance=self.vm, user=owner, is_change=True)
response, cloned = self.clone(
owner, lambda: Instance.objects.filter(pk=self.vm.pk).update(compute=self.target)
)
self.assertFalse(cloned)
self.assertIn("Instance operation is busy. Please retry.", [str(m) for m in response.wsgi_request._messages])
def test_a_template_unmarked_while_the_request_waited_is_not_cloned_by_a_viewer(self):
from django.contrib.auth.models import Permission
viewer = get_user_model().objects.create_user("clone_viewer", password="x")
for codename in ("view_instances", "clone_instances"):
viewer.user_permissions.add(Permission.objects.get(codename=codename))
Instance.objects.filter(pk=self.vm.pk).update(is_template=True)
response, cloned = self.clone(viewer, lambda: Instance.objects.filter(pk=self.vm.pk).update(is_template=False))
self.assertFalse(cloned)
self.assertEqual(response.status_code, 403)
def test_a_clone_checks_the_quota_against_the_source_as_it_is_under_the_lock(self):
from accounts.models import UserInstance
from django.contrib.auth.models import Permission
owner = get_user_model().objects.create_user("clone_quota", password="x")
owner.user_permissions.add(Permission.objects.get(codename="clone_instances"))
UserInstance.objects.create(instance=self.vm, user=owner, is_change=True)
self.client.force_login(owner)
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_disk_devices.return_value = []
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.get_memory.return_value = 512
@contextmanager
def compute_lock_after_a_resize(compute, timeout=15.0, *, shared=False):
wvm.return_value.get_vcpu.return_value = 8 # resized meanwhile
yield
with patch("instances.views.libvirt_compute_lock", compute_lock_after_a_resize), patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
), patch(
"instances.views.utils.check_user_quota",
side_effect=lambda user, count, cpu, memory, disk: "cpu" if cpu > 4 else "",
):
response = self.client.post(reverse("instances:clone", args=[self.vm.id]), {"name": "grown-clone"})
self.assertFalse(wvm.return_value.clone_instance.called)
self.assertTrue(any("quota" in str(m) for m in response.wsgi_request._messages))

View file

@ -0,0 +1,63 @@
"""A new disk or CD-ROM gets a name neither definition uses: on an active
VM a disk can be pending in the persistent definition only, or still in the
running VM only, and the attach goes to both."""
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
def dev(name, bus):
return {"dev": name, "bus": bus, "image": f"{name}.qcow2", "storage": "default", "path": f"/pool/{name}.qcow2",
"format": "qcow2", "size": 1 << 30}
class NewDiskNameTestCase(TestCase):
def setUp(self):
self.client.force_login(get_user_model().objects.create_superuser("nd-admin", "nd@example.com", "x"))
compute = Compute.objects.create(name="nd", hostname="127.0.0.1:1", login="root", password="", type=1)
self.instance = Instance.objects.create(compute=compute, name="nd-vm", uuid="aaaaaaaa-5555-2222-3333-444444444444")
def attached_name(self, view, data, live=((), ()), config=((), ())):
"""The name view attaches with; live and config are (disks, media) of each definition."""
with patch("instances.models.wvmInstance") as wvm, patch("instances.views.wvmStorage") as storage, patch(
"instances.views.wvmCreate"
) as create:
proxy = wvm.return_value
proxy.get_disk_devices.side_effect = lambda **kw: list((config if kw.get("config") else live)[0])
proxy.get_media_devices.side_effect = lambda **kw: list((config if kw.get("config") else live)[1])
proxy.get_disk_bus_types.return_value = ["virtio", "sata", "scsi"]
proxy.get_cache_modes.return_value = {"default": "", "none": ""}
proxy.get_machine_type.return_value = "q35"
storage.return_value.get_volumes.return_value = ["data.qcow2"]
storage.return_value.get_type.return_value = "dir"
storage.return_value.get_volume_type.return_value = "file"
storage.return_value.get_volume_format_type.return_value = "qcow2"
create.return_value.create_volume.return_value = "/pool/data.qcow2"
self.client.post(reverse(f"instances:{view}", args=[self.instance.id]), data)
proxy.attach_disk.assert_called_once()
return proxy.attach_disk.call_args.args[0]
VIEWS = (
("add_new_vol", {"storage": "default", "name": "data", "format": "qcow2", "size": "1", "cache": "default"}),
("add_existing_vol", {"selected_storage": "default", "vols": "data.qcow2", "cache": "default"}),
("add_cdrom", {}),
)
def test_a_name_either_definition_uses_is_not_given_again(self):
vda = dev("vda", "virtio")
cases = (
# bus, live (disks, media), persistent (disks, media), expected name
("scsi", ([vda], []), ([vda, dev("sda", "sata")], []), "sdb"), # pending sata rename; scsi shares sd
("sata", ([vda], []), ([vda], [dev("sda", "sata")]), "sdb"), # pending CD-ROM
("virtio", ([vda, dev("vdb", "virtio")], []), ([vda], []), "vdc"), # not yet released by the guest
("virtio", ([vda], []), ([vda], []), "vdb"), # both the same, as on a stopped VM
)
for view, data in self.VIEWS:
for bus, live, config, expected in cases:
with self.subTest(view=view, bus=bus, expected=expected):
self.assertEqual(self.attached_name(view, {**data, "bus": bus}, live, config), expected)

View file

@ -0,0 +1,230 @@
"""
The VM page renders a control only for users the backend lets use it:
power to superusers and owners; the console, virt-viewer file and VDI URL to
superusers and owners (can_open_console); root password, SSH key, resize and
options to superusers and owners with is_change; per-vCPU hotplug, video
model and guest agent to superusers; clone with clone_instances on a template
or with is_change; snapshots with snapshot_instances and is_change, on a
template only for staff. is_staff and the global view_instances permission
alone are read-only.
"""
import shutil
import subprocess
import unittest
from unittest.mock import PropertyMock, patch
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from lxml import html as lxml_html
from accounts.models import UserInstance
from appsettings.models import AppSettings
from computes.models import Compute
from instances.models import Instance
CONSOLE = {"console", "vv file", "vdi"}
POWER = {"power"}
CHANGE = {"root password", "ssh key", "resize", "options"}
SUPERUSER_ONLY = {"vcpu hotplug", "video model", "guest agent"}
class PageControls:
def setUp(self):
AppSettings.objects.filter(
key__in=["SHOW_ACCESS_ROOT_PASSWORD", "SHOW_ACCESS_SSH_KEYS", "VIEW_INSTANCE_DETAIL_BOTTOM_BAR"]
).update(value="True")
self.compute = Compute.objects.create(
name="ctl-compute", hostname="127.0.0.1:1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute, name="ctl-vm", uuid="dddddddd-eeee-ffff-0000-111111111111"
)
def user(self, name, staff=False, perms=(), owner=None):
user = get_user_model().objects.create_user(name, password="x", is_staff=staff)
for codename in perms:
user.user_permissions.add(Permission.objects.get(codename=codename))
if owner is not None:
UserInstance.objects.create(instance=self.instance, user=user, **owner)
return user
def controls(self, user, status=1):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as mock_wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
):
proxy = mock_wvm.return_value
proxy.get_memory.return_value = 1024
proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
proxy.get_vcpu.return_value = 2
proxy.get_cur_vcpu.return_value = 1
proxy.get_max_cpus.return_value = [1, 2, 3, 4]
# a running VM with hotpluggable vCPUs shows the per-vCPU buttons
proxy.get_vcpus.return_value = {
0: {"enabled": "yes", "hotpluggable": "no"},
1: {"enabled": "no", "hotpluggable": "yes"},
}
for getter in ("get_networks", "get_ifaces", "get_storages", "get_disk_devices",
"get_media_devices", "get_net_devices", "get_snapshot",
"get_external_snapshots"):
getattr(proxy, getter).return_value = []
proxy.get_console_type.return_value = "vnc"
proxy.get_status.return_value = status
response = self.client.get(reverse("instances:instance", args=[self.instance.id]))
self.assertEqual(response.status_code, 200)
self.last_page = response.content.decode()
doc = lxml_html.fromstring(response.content)
pk = self.instance.id
def form(name):
return bool(doc.xpath("//form[@action=$a]", a=reverse(f"instances:{name}", args=[pk])))
found = {
"console": bool(doc.xpath("//button[@id='consoleBtnGroup']")),
"vv file": bool(doc.xpath("//a[@href=$a]", a=reverse("instances:getvvfile", args=[pk]))),
"vdi": bool(doc.xpath("//*[@id='vdiconsole']")),
"power": form("poweroff") or form("poweron"),
"root password": form("rootpasswd"),
"ssh key": form("add_public_key"),
# a running VM with hotplug shows per-vCPU buttons instead of the CPU form
"resize": form("resize_memory"),
"options": form("change_options"),
"console settings": form("update_console"),
# host pages (superuser-only views)
"host links": bool(doc.xpath("//a[@href=$a]", a=reverse("overview", args=[self.compute.id]))),
# a link to the destroy confirmation page
"destroy": bool(doc.xpath("//a[@href=$a]", a=reverse("instances:destroy", args=[pk]))),
"vcpu hotplug": form("set_vcpu"),
"video model": form("set_video_model"),
"guest agent": form("set_guest_agent"),
"clone": bool(doc.xpath("//*[@id='clone']")),
"snapshots": bool(doc.xpath("//*[@id='snapshots']")),
}
return {name for name, present in found.items() if present}
class PageControlsTestCase(PageControls, TestCase):
@unittest.skipUnless(shutil.which("node"), "node is not installed")
def test_the_page_scripts_parse(self):
superuser = get_user_model().objects.create_superuser("ctl_js", "ctl_js@example.com", "x")
viewer = self.user("ctl_js_viewer", perms=("view_instances",))
for user in (superuser, viewer):
self.controls(user)
scripts = lxml_html.fromstring(self.last_page).xpath("//script[not(@src)]/text()")
for number, script in enumerate(scripts):
with self.subTest(user=user.username, script=number):
result = subprocess.run(
["node", "--check", "-"], input=script, capture_output=True, text=True, timeout=30
)
self.assertEqual(result.returncode, 0, result.stderr)
def test_superuser_sees_every_control(self):
superuser = get_user_model().objects.create_superuser("ctl_super", "ctl_super@example.com", "x")
self.assertEqual(
self.controls(superuser),
CONSOLE | POWER | CHANGE | SUPERUSER_ONLY
| {"clone", "snapshots", "console settings", "destroy", "host links"},
)
def test_global_viewers_see_nothing_to_act_on(self):
perms = ("view_instances", "clone_instances", "snapshot_instances")
for user in (self.user("ctl_viewer", perms=perms), self.user("ctl_staff", staff=True, perms=perms)):
with self.subTest(user=user.username):
self.assertEqual(self.controls(user), set())
def test_owner_without_change_powers_and_opens_the_console(self):
owner = self.user("ctl_owner", perms=("clone_instances", "snapshot_instances"), owner={})
self.assertEqual(self.controls(owner), CONSOLE | POWER)
def test_owner_with_change_gets_change_clone_and_snapshots(self):
changer = self.user("ctl_changer", perms=("clone_instances", "snapshot_instances"),
owner={"is_change": True})
self.assertEqual(self.controls(changer), CONSOLE | POWER | CHANGE | {"clone", "snapshots"})
def test_a_paused_vm_can_be_destroyed(self):
# destroy stops a paused VM like a running one
owner = self.user("paused_deleter", owner={"is_delete": True})
self.assertIn("destroy", self.controls(owner, status=3))
def test_disks_grow_while_running_paused_or_shut_off(self):
# QEMU grows a running or paused VM's disk itself (blockResize)
changer = self.user("disk_resizer", owner={"is_change": True})
for status, enabled in ((1, True), (3, True), (5, True), (7, False)):
with self.subTest(status=status):
self.controls(changer, status=status)
buttons = lxml_html.fromstring(self.last_page).xpath(
"//form[@action=$a]//button[@type='submit']",
a=reverse("instances:resize_disk", args=[self.instance.id]),
)
self.assertEqual(bool(buttons), enabled)
def test_owner_with_change_and_no_extra_permissions(self):
changer = self.user("ctl_plain_changer", owner={"is_change": True})
self.assertEqual(self.controls(changer), CONSOLE | POWER | CHANGE)
class TemplatePageControlsTestCase(PageControls, TestCase):
def setUp(self):
super().setUp()
self.instance.is_template = True
self.instance.save()
def test_a_template_is_cloned_by_viewing_it(self):
viewer = self.user("tpl_viewer", perms=("view_instances", "clone_instances"))
self.assertEqual(self.controls(viewer, status=5), {"clone"})
def test_only_staff_owners_change_a_template(self):
owner = self.user("tpl_plain_changer", owner={"is_change": True})
staff = self.user("tpl_staff_owner", staff=True, owner={"is_change": True})
self.assertEqual(self.controls(owner, status=5) & CHANGE, set())
self.assertEqual(self.controls(staff, status=5) & CHANGE, CHANGE)
def test_console_settings_of_a_template_are_for_staff_owners(self):
flags = {"is_change": True, "is_vnc": True}
owner = self.user("tpl_vnc_owner", owner=flags)
staff = self.user("tpl_vnc_staff", staff=True, owner=flags)
self.assertNotIn("console settings", self.controls(owner, status=5))
self.assertIn("console settings", self.controls(staff, status=5))
def test_only_staff_owners_destroy_a_template(self):
owner = self.user("tpl_deleter", owner={"is_delete": True})
staff = self.user("tpl_staff_deleter", staff=True, owner={"is_delete": True})
self.assertNotIn("destroy", self.controls(owner, status=5))
self.assertIn("destroy", self.controls(staff, status=5))
def test_snapshots_of_a_template_are_for_staff_owners(self):
perms = ("clone_instances", "snapshot_instances")
owner = self.user("tpl_changer", perms=perms, owner={"is_change": True})
staff = self.user("tpl_staff_changer", staff=True, perms=perms, owner={"is_change": True})
self.assertNotIn("snapshots", self.controls(owner, status=5))
self.assertIn("snapshots", self.controls(staff, status=5))
class TemplateSnapshotRuleTestCase(PageControls, TestCase):
"""The backend side of the template rule: only staff owners (and
superusers) take a snapshot of a template; other owners with is_change
and snapshot_instances are turned away without a libvirt call."""
def setUp(self):
super().setUp()
self.instance.is_template = True
self.instance.save()
def snapshot(self, user):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as mock_wvm:
self.client.post(
reverse("instances:snapshot", args=[self.instance.id]), {"name": "s1", "description": ""}
)
return mock_wvm.return_value.create_snapshot.called
def test_only_staff_owners_snapshot_a_template(self):
perms = ("snapshot_instances",)
owner = self.user("snap_changer", perms=perms, owner={"is_change": True})
staff = self.user("snap_staff_changer", staff=True, perms=perms, owner={"is_change": True})
self.assertFalse(self.snapshot(owner))
self.assertTrue(self.snapshot(staff))

View file

@ -0,0 +1,137 @@
"""On an active VM an edit changes the persistent definition and is pending
until the next start. The edit forms show that definition, so a save does
not post the running VM's value back over a pending change."""
from unittest.mock import PropertyMock, patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from lxml import html
from vrtManager import util
def disk(dev, cache, serial):
return {
"dev": dev, "bus": "virtio", "image": f"{dev}.qcow2", "storage": "default", "path": f"/pool/{dev}.qcow2",
"format": "qcow2", "backing_file": None, "size": 1 << 30, "used": 1 << 20, "cache": cache, "io": "default",
"discard": "default", "detect_zeroes": "default", "readonly": False, "shareable": False, "serial": serial,
}
class PendingEditsTestCase(TestCase):
def setUp(self):
self.client.force_login(get_user_model().objects.create_superuser("pe-admin", "pe@example.com", "x"))
compute = Compute.objects.create(name="pe", hostname="127.0.0.1:1", login="root", password="", type=1)
self.instance = Instance.objects.create(compute=compute, name="pe-vm", uuid="aaaaaaaa-1111-2222-3333-444444444444")
def page(self, live=(), config=(), qos=({}, {}), status=1, **getters):
"""live and config: disks; qos and getters (get_vcpu=(2, 4)): values of
the live and the persistent definition."""
with patch("instances.models.wvmInstance") as wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
):
proxy = wvm.return_value
proxy.get_status.return_value = status
proxy.get_memory.return_value = proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
getters = {"get_vcpu": (1, 1), "get_cur_vcpu": (1, 1), "get_title": ("", ""),
"get_description": ("", ""), **getters}
for getter, values in getters.items():
getattr(proxy, getter).side_effect = lambda config=False, values=values: values[config]
proxy.get_max_cpus.return_value = [1, 2, 3, 4]
proxy.get_vcpus.return_value = {}
for getter in ("get_networks", "get_ifaces", "get_storages", "get_media_devices", "get_net_devices",
"get_snapshot", "get_external_snapshots"):
getattr(proxy, getter).return_value = []
proxy.get_disk_devices.side_effect = lambda **kw: config if kw.get("config") else live
proxy.get_all_qos.side_effect = lambda **kw: qos[1] if kw.get("config") else qos[0]
proxy.get_console_type.return_value = "vnc"
proxy.get_video_models.return_value = ["vga", "virtio"]
proxy.get_cache_modes.return_value = {"default": "Default", "none": "Disabled"}
response = self.client.get(reverse("instances:instance", args=[self.instance.id]))
self.assertEqual(response.status_code, 200)
return html.fromstring(response.content)
def test_the_disk_edit_form_shows_the_pending_definition(self):
# running: cache=none and a new disk vdb pending, vda's serial live only
doc = self.page(
live=[disk("vda", "default", "live-serial")],
config=[disk("vda", "none", ""), disk("vdb", "default", "")],
)
forms = doc.xpath("//form[@action=$a]", a=reverse("instances:edit_volume", args=[self.instance.id]))
self.assertEqual([f.xpath("string(.//input[@name='dev']/@value)") for f in forms], ["vda", "vdb"])
vda = forms[0]
self.assertEqual(vda.xpath(".//select[@name='vol_cache']/option[@selected]/@value"), ["none"])
self.assertEqual(vda.xpath("string(.//input[@name='vol_serial']/@value)"), "")
def test_the_qos_form_shows_the_pending_definition(self):
mac = "52:54:10:00:00:01"
inbound = {"direction": "inbound", "average": "500", "peak": "0", "burst": "0", "floor": None}
doc = self.page(qos=({mac: [inbound]}, {mac: [{**inbound, "average": "1000"}, {**inbound, "direction": "outbound"}]}))
self.assertEqual(doc.xpath("//input[@name='qos_average']/@value"), ["1000", "500"])
# the pending outbound has a row
self.assertEqual([" ".join(t.split()) for t in doc.xpath("//label[@class='col-form-label']/text()")],
[f"{mac} Inbound", f"{mac} Outbound"])
def test_a_disk_with_a_pending_source_is_not_deleted(self):
# running: vda is A, its definition for the next start uses B
with patch("instances.models.wvmInstance") as wvm, patch("instances.views.wvmStorage") as storage:
proxy = wvm.return_value
live, pending = disk("vda", "default", ""), {**disk("vda", "default", ""), "path": "/pool/b.qcow2"}
proxy.get_disk_devices.side_effect = lambda **kw: [pending] if kw.get("config") else [live]
self.client.post(reverse("instances:delete_vol", args=[self.instance.id]), {"dev": "vda"})
proxy.detach_disk.assert_not_called()
storage.return_value.del_volume.assert_not_called()
def test_the_options_and_cpu_forms_show_the_pending_definition(self):
doc = self.page(get_vcpu=(2, 4), get_cur_vcpu=(1, 3), get_title=("old", "new"),
get_description=("live text", "pending text"))
self.assertEqual(doc.xpath("//input[@name='title']/@value"), ["new"])
self.assertEqual(doc.xpath("//textarea[@name='description']/text()"), ["pending text"])
self.assertEqual(doc.xpath("//select[@name='vcpu']/option[@selected]/@value"), ["4"])
self.assertEqual(doc.xpath("//select[@name='cur_vcpu']/option[@selected]/@value"), ["3"])
def test_buttons_shown_as_disabled_cannot_submit(self):
# running: the CPU, options, video and XML forms wait for a shutdown
doc = self.page(live=[disk("vda", "default", "")], config=[disk("vda", "default", "")])
shown = doc.xpath("//button[contains(concat(' ', @class, ' '), ' disabled ')]")
self.assertGreater(len(shown), 5)
self.assertEqual([b for b in shown if b.get("disabled") is None], [])
for action in ("resizevm_cpu", "change_options", "set_video_model", "change_xml", "detach_vol", "delete_vol"):
with self.subTest(action):
(form,) = doc.xpath("//form[@action=$a]", a=reverse(f"instances:{action}", args=[self.instance.id]))
self.assertTrue(all(b.get("disabled") is not None for b in form.xpath(".//button")))
def test_the_boot_video_and_console_forms_show_the_pending_definition(self):
cd = {"dev": "sda", "image": "pending.iso", "storage": "default", "path": "/pool/pending.iso", "bus": "sata"}
with patch("instances.models.Instance.config_networks", new_callable=PropertyMock, return_value=[]):
doc = self.page(
live=[disk("vda", "default", "")], config=[disk("vda", "default", ""), disk("vdb", "default", "")],
get_bootmenu=(False, True), get_bootorder=({}, {0: {"type": "file", "dev": "cdrom", "target": "sda"}}),
get_media_devices=([], [cd]), get_video_model=("vga", "virtio"),
get_console_listener_addr=("127.0.0.1", "0.0.0.0"), get_console_keymap=("", "de"),
get_console_passwd=("live-pw", "pending-pw"),
)
(boot,) = doc.xpath("//form[@action=$a]", a=reverse("instances:set_bootorder", args=[self.instance.id]))
self.assertEqual(boot.xpath(".//input[@type='checkbox']/@value"), ["disk:vda", "disk:vdb", "cdrom:sda"])
self.assertIn("1:sda", doc.xpath("string(//div[label[contains(., ':')]])"))
self.assertEqual(doc.xpath("//select[@name='video_model']/option[@selected]/@value"), ["virtio"])
self.assertEqual(doc.xpath("//select[@name='keymap']/option[@selected]/@value"), ["de"])
self.assertEqual(doc.xpath("//select[@name='listen_on']/option[@selected]/@value"), ["0.0.0.0"])
self.assertEqual(doc.xpath("//input[@name='password']/@value"), ["pending-pw"])
def test_a_boot_order_choice_not_in_the_definition_is_refused(self):
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.set_bootorder.side_effect = util.OperationError("Boot device vdz is not in the definition")
response = self.client.post(reverse("instances:set_bootorder", args=[self.instance.id]),
{"bootorder": "disk:vda,disk:vdz"})
self.assertEqual([str(m) for m in get_messages(response.wsgi_request)], ["Boot device vdz is not in the definition"])
def test_an_active_vm_says_its_settings_apply_at_the_next_start(self):
for status, shown in ((1, True), (3, True), (5, False)):
with self.subTest(status=status):
self.assertEqual(bool(self.page(status=status).xpath("//p[@id='next-start-note']")), shown)

View file

@ -0,0 +1,183 @@
"""check_user_quota counts every VM of the user and refuses an increase it
cannot verify (fail closed); requests that add nothing are not checked."""
from types import SimpleNamespace
from unittest.mock import PropertyMock, patch
from accounts.models import UserAttributes, UserInstance
from appsettings.settings import get_settings
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from instances.utils import QUOTA_UNVERIFIED, check_user_quota
from libvirt import VIR_DOMAIN_PAUSED, VIR_DOMAIN_RUNNING
from vrtManager.util import OperationError
def vm_reader(vcpu=2, memory=1024, disk_gib=10):
def make(*args, **kwargs):
return SimpleNamespace(
get_vcpu=lambda: vcpu,
get_memory=lambda: memory,
get_disk_devices=lambda: [{"size": disk_gib << 30}],
)
return make
class QuotaTests(TestCase):
def setUp(self):
get_settings() # app settings are normally loaded by middleware
self.user = get_user_model().objects.create_user("quota-user", password="pw")
UserAttributes.objects.create(user=self.user, max_instances=5, max_cpus=8, max_memory=8192, max_disk_size=100)
self.up = Compute.objects.create(name="up", hostname="wvc-alias", login="root", password="", type=2)
self.down = Compute.objects.create(name="down", hostname="192.0.2.1", login="u", password="p", type=1)
self.status_checks = []
def own(self, compute, n):
vm = Instance.objects.create(compute=compute, name=f"vm-{compute.name}-{n}", uuid=f"{n:08d}-0000-0000-0000-{compute.pk:012d}")
UserInstance.objects.create(user=self.user, instance=vm)
return vm
def check(self, *delta, reader=None):
test = self
def status(compute):
test.status_checks.append(id(compute))
return compute.pk != test.down.pk
reader = reader or vm_reader()
with patch.object(Compute, "status", property(status)), patch(
"instances.utils.wvmInstance", side_effect=reader
) as wvm:
result = check_user_quota(self.user, *delta)
return result.split(" ")[0], wvm.call_count # without the QUOTA_DEBUG detail
def test_vms_on_a_host_without_a_tcp_route_are_counted(self):
# an ssh_config alias: the old TCP probe failed and skipped these VMs
for n in range(4):
self.own(self.up, n)
self.assertEqual(self.check(0, 1, 0, 0), ("cpu", 4))
def test_a_host_that_is_down_refuses_an_increase(self):
self.own(self.up, 1)
self.own(self.down, 2)
self.assertEqual(self.check(0, 1, 0, 0)[0], QUOTA_UNVERIFIED)
def test_a_vm_that_cannot_be_read_refuses_an_increase(self):
self.own(self.up, 1)
def gone(*args, **kwargs):
raise OperationError("Domain not found")
self.assertEqual(self.check(0, 0, 512, 0, reader=gone)[0], QUOTA_UNVERIFIED)
def test_each_host_is_checked_once(self):
for n in range(3):
self.own(self.up, n)
self.check(0, 1, 0, 0)
# one Compute object asked (its status is cached), not one per VM
self.assertEqual(len(set(self.status_checks)), 1)
def test_a_user_over_quota_can_still_shrink(self):
for n in range(5):
self.own(self.up, n) # 10 vCPUs used of 8
self.assertEqual(self.check(0, -1, 0, 0), ("", 0))
self.assertEqual(self.check(0, 0, -512, 0), ("", 0))
def test_unlimited_users_are_not_checked(self):
UserAttributes.objects.filter(user=self.user).update(max_instances=-1, max_cpus=-1, max_memory=0, max_disk_size=-1)
self.own(self.down, 1)
self.assertEqual(self.check(1, 4, 4096, 50), ("", 0))
def test_only_an_instance_limit_needs_no_host(self):
UserAttributes.objects.filter(user=self.user).update(max_instances=2, max_cpus=-1, max_memory=-1, max_disk_size=-1)
self.own(self.down, 1)
self.assertEqual(self.check(1, 4, 4096, 50), ("", 0))
self.own(self.up, 2)
self.assertEqual(self.check(1, 4, 4096, 50), ("instance", 0))
def test_instance_limit_is_checked_before_any_host(self):
for n in range(5):
self.own(self.down, n)
self.assertEqual(self.check(1, 0, 0, 0), ("instance", 0))
def test_templates_are_not_counted(self):
for n in range(4):
vm = self.own(self.up, n)
Instance.objects.filter(pk=vm.pk).update(is_template=True)
self.assertEqual(self.check(0, 2, 0, 0), ("", 3))
class QuotaViewTests(TestCase):
"""The resize views turn the result into a message and charge only what changes."""
def setUp(self):
get_settings()
self.user = get_user_model().objects.create_user("quota-view-user", password="pw")
self.client.force_login(self.user)
compute = Compute.objects.create(name="qv", hostname="10.0.0.1", login="u", password="p", type=1)
self.vm = Instance.objects.create(compute=compute, name="qv-vm", uuid="12121212-0000-0000-0000-000000000000")
UserInstance.objects.create(user=self.user, instance=self.vm, is_change=True)
def post(self, view, data, quota="", status=VIR_DOMAIN_RUNNING):
with patch("instances.views.utils.check_user_quota", return_value=quota) as check, patch(
"instances.models.wvmInstance"
) as wvm:
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.get_memory.return_value = 2048
wvm.return_value.get_cur_memory.return_value = 2048
wvm.return_value.get_status.return_value = status
wvm.return_value.instance.isActive.return_value = status != 5
response = self.client.post(reverse(view, args=[self.vm.id]), data)
messages = [str(m) for m in get_messages(response.wsgi_request)]
return messages, check, wvm.return_value
def test_unverified_quota_has_its_own_message(self):
messages, _, proxy = self.post("instances:resizevm_cpu", {"vcpu": 2, "cur_vcpu": 2}, quota=QUOTA_UNVERIFIED)
self.assertEqual(len(messages), 1)
self.assertIn("a host of your virtual machines cannot be reached", messages[0])
self.assertNotIn("quota reached", messages[0])
proxy.resize_cpu.assert_not_called()
def test_running_vm_memory_charges_no_maximum_change(self):
# a running VM keeps its maximum: resize_mem changes the current memory only
_, check, proxy = self.post("instances:resize_memory", {"memory": 8192, "cur_memory": 1024})
self.assertEqual(check.call_args.args[1:], (0, 0, 0, 0))
# the maximum passed is the current one: if the VM shut down meanwhile,
# resize_mem would write it, and it must not be the unchecked 8192
proxy.resize_mem.assert_called_once_with("1024", 2048)
def test_paused_vm_memory_charges_no_maximum_change(self):
_, check, proxy = self.post("instances:resize_memory", {"memory": 8192, "cur_memory": 1024}, status=VIR_DOMAIN_PAUSED)
self.assertEqual(check.call_args.args[1:], (0, 0, 0, 0))
proxy.resize_mem.assert_called_once_with("1024", 2048)
def test_shut_off_vm_memory_charges_the_maximum_change(self):
_, check, _ = self.post("instances:resize_memory", {"memory": 4096, "cur_memory": 1024}, status=5)
self.assertEqual(check.call_args.args[1:], (0, 0, 2048, 0))
class DetailPageQuotaTests(TestCase):
def test_the_detail_page_does_not_read_every_vm_for_the_quota(self):
get_settings()
user = get_user_model().objects.create_user("quota-detail-user", password="pw")
compute = Compute.objects.create(name="qd", hostname="10.0.0.1", login="u", password="p", type=1)
vm = Instance.objects.create(compute=compute, name="qd-vm", uuid="34343434-0000-0000-0000-000000000000")
UserInstance.objects.create(user=user, instance=vm)
self.client.force_login(user)
with patch("instances.models.wvmInstance") as wvm, patch(
"instances.views.utils.check_user_quota", side_effect=AssertionError("quota checked on GET")
), patch.object(Compute, "status", new_callable=PropertyMock, return_value=True):
proxy = wvm.return_value
proxy.get_memory.return_value = 1024
proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
for name in ("get_networks", "get_ifaces", "get_storages", "get_disk_devices", "get_media_devices", "get_net_devices"):
getattr(proxy, name).return_value = []
proxy.get_status.return_value = 5
response = self.client.get(reverse("instances:instance", args=[vm.id]))
self.assertEqual(response.status_code, 200)

View file

@ -0,0 +1,62 @@
import threading
import time
from unittest.mock import patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.db import connection
from django.test import Client, TransactionTestCase, override_settings
from django.urls import reverse
from instances.models import Instance
QUOTA_CPUS = 4
# Sessions and messages in cookies: concurrent writes to the in-memory test
# database would fail for reasons unrelated to the quota race.
@override_settings(
SESSION_ENGINE="django.contrib.sessions.backends.signed_cookies",
MESSAGE_STORAGE="django.contrib.messages.storage.cookie.CookieStorage",
)
class QuotaRaceTestCase(TransactionTestCase):
"""Two concurrent resizes of one user's VMs must not both pass the quota."""
def setUp(self):
self.user = get_user_model().objects.create_user("quota_user", password="pw")
compute = Compute.objects.create(name="quota-compute", hostname="127.0.0.1", login="", password="", type=4)
self.vms = [
Instance.objects.create(compute=compute, name=f"quota-vm-{i}", uuid=f"1111111{i}-2222-3333-4444-555555555555")
for i in range(2)
]
for vm in self.vms:
UserInstance.objects.create(user=self.user, instance=vm, is_change=True)
self.allocated = 2 # two VMs with one vCPU each
def fake_quota(self, user, instance, cpu, memory, disk):
seen = self.allocated
time.sleep(0.3) # widen the window between the check and the change
return "cpu" if seen + cpu > QUOTA_CPUS else ""
def fake_resize(self, cur_vcpu, vcpu):
self.allocated += int(vcpu) - 1
def resize(self, vm):
client = Client()
client.force_login(self.user)
client.post(reverse("instances:resizevm_cpu", args=[vm.id]), {"vcpu": 3, "cur_vcpu": 3})
connection.close()
def test_second_concurrent_resize_is_refused(self):
with patch("instances.views.utils.check_user_quota", self.fake_quota), patch(
"instances.models.wvmInstance"
) as wvm:
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.resize_cpu.side_effect = self.fake_resize
threads = [threading.Thread(target=self.resize, args=(vm,)) for vm in self.vms]
for t in threads:
t.start()
for t in threads:
t.join()
self.assertEqual(wvm.return_value.resize_cpu.call_count, 1)
self.assertLessEqual(self.allocated, QUOTA_CPUS)

View file

@ -0,0 +1,117 @@
import json
import socket
from unittest.mock import MagicMock, patch
from django.test import RequestFactory, TestCase
from django.urls import reverse
from computes.models import Compute
from instances.models import Instance
class SetRootPassTestCase(TestCase):
def setUp(self):
self.client.login(request=RequestFactory().get("/"), username="admin", password="admin")
self.compute = Compute.objects.create(
name="test_compute_root_pass",
hostname="localhost",
type=1,
)
self.instance = Instance.objects.create(
compute=self.compute,
name="root-pass-vm",
uuid="87654321-4321-4321-4321-210987654321",
)
@patch("socket.socket")
@patch.object(Instance, "proxy")
def test_set_root_pass_post(self, mock_proxy, mock_socket_cls):
# Renamed on the host: gstfsd must get the name of this UUID's domain
mock_proxy.instance.name.return_value = "renamed-on-host"
mock_proxy.get_status.return_value = 5 # shut off
mock_sock = MagicMock()
mock_socket_cls.return_value = mock_sock
replies = iter([json.dumps({"return": "success"}).encode(), b""] * 2)
# one reply, then gstfsd closes the connection
mock_sock.recv.side_effect = lambda size: next(replies)
response = self.client.post(
reverse("instances:rootpasswd", args=[self.instance.id]),
{"passwd": "newSecretPassword123"}
)
# Redirects back to referer or instance detail
self.assertEqual(response.status_code, 302)
# Check socket sent the command with hashed password
self.assertTrue(mock_sock.sendall.called)
sent_bytes = mock_sock.sendall.call_args[0][0]
data = json.loads(sent_bytes.decode())
self.assertEqual(data["action"], "password")
self.assertEqual(data["vname"], "renamed-on-host")
# SHA-512 crypt with a random salt, not the old fixed one
self.assertTrue(data["passwd"].startswith("$6$"))
self.assertFalse(data["passwd"].startswith("$6$kgPoiREy$"))
def test_set_root_pass_get_not_allowed(self):
response = self.client.get(reverse("instances:rootpasswd", args=[self.instance.id]))
self.assertEqual(response.status_code, 405)
def test_set_root_pass_not_found(self):
response = self.client.post(reverse("instances:rootpasswd", args=[99999]), {"passwd": "secret"})
self.assertEqual(response.status_code, 404)
@patch("socket.socket")
@patch.object(Instance, "proxy")
def test_same_password_gets_a_different_salt_each_time(self, mock_proxy, mock_socket_cls):
mock_proxy.instance.name.return_value = "root-pass-vm"
mock_proxy.get_status.return_value = 5
mock_sock = MagicMock()
mock_socket_cls.return_value = mock_sock
replies = iter([json.dumps({"return": "success"}).encode(), b""] * 2)
# one reply, then gstfsd closes the connection
mock_sock.recv.side_effect = lambda size: next(replies)
url = reverse("instances:rootpasswd", args=[self.instance.id])
self.client.post(url, {"passwd": "samePassword1"})
self.client.post(url, {"passwd": "samePassword1"})
hashes = [json.loads(c[0][0].decode())["passwd"] for c in mock_sock.sendall.call_args_list]
self.assertEqual(len(hashes), 2)
self.assertNotEqual(hashes[0], hashes[1])
@patch("socket.socket")
@patch.object(Instance, "proxy")
def test_unreachable_gstfsd_is_an_error_message_not_a_crash(self, mock_proxy, mock_socket_cls):
mock_proxy.instance.name.return_value = "root-pass-vm"
mock_proxy.get_status.return_value = 5
mock_sock = MagicMock()
mock_socket_cls.return_value = mock_sock
mock_sock.connect.side_effect = socket.timeout("timed out")
response = self.client.post(
reverse("instances:rootpasswd", args=[self.instance.id]), {"passwd": "x"}
)
self.assertEqual(response.status_code, 302)
mock_sock.settimeout.assert_called()
@patch("socket.socket")
@patch.object(Instance, "proxy")
def test_add_public_key_unreachable_gstfsd_is_an_error_message(self, mock_proxy, mock_socket_cls):
from accounts.models import UserSSHKey
from django.contrib.auth import get_user_model
admin = get_user_model().objects.get(username="admin")
key = UserSSHKey.objects.create(user=admin, keyname="k", keypublic="ssh-ed25519 AAAA k")
mock_proxy.instance.name.return_value = "root-pass-vm"
mock_proxy.get_status.return_value = 5
mock_sock = MagicMock()
mock_socket_cls.return_value = mock_sock
mock_sock.connect.side_effect = ConnectionRefusedError()
response = self.client.post(
reverse("instances:add_public_key", args=[self.instance.id]), {"sshkeyid": key.id}
)
self.assertEqual(response.status_code, 302)
mock_sock.settimeout.assert_called()

View file

@ -0,0 +1,419 @@
from unittest.mock import MagicMock, patch
from django.core.exceptions import PermissionDenied
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.http import Http404
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
from instances.views import get_instance
class InstanceSecurityMutationsTestCase(TestCase):
def setUp(self):
User = get_user_model()
self.superuser = User.objects.create_superuser(
username="sec_super", email="super@example.com", password="password"
)
self.owner = User.objects.create_user(
username="sec_owner", password="password"
)
self.change_user = User.objects.create_user(
username="sec_change_user", password="password"
)
self.viewer = User.objects.create_user(
username="sec_viewer", password="password"
)
# Viewer only has global view_instances permission
view_perm = Permission.objects.get(codename="view_instances")
self.viewer.user_permissions.add(view_perm)
self.compute = Compute.objects.create(
name="sec-compute",
hostname="127.0.0.1",
login="root",
password="",
type=1,
)
self.instance = Instance.objects.create(
compute=self.compute,
name="sec-test-vm",
uuid="11111111-2222-3333-4444-555555555555",
)
# Owner has basic userinstance (power enabled, change/delete disabled)
self.owner_ui = UserInstance.objects.create(
instance=self.instance, user=self.owner, is_change=False, is_delete=False
)
# Change user has is_change=True
self.change_ui = UserInstance.objects.create(
instance=self.instance, user=self.change_user, is_change=True, is_delete=False
)
# Mock instance.proxy on instance dict
self.mock_proxy = MagicMock()
self.instance.__dict__["proxy"] = self.mock_proxy
def test_power_endpoints_reject_get_requests(self):
self.client.force_login(self.owner)
endpoints = [
reverse("instances:poweron", args=[self.instance.id]),
reverse("instances:poweroff", args=[self.instance.id]),
reverse("instances:powercycle", args=[self.instance.id]),
reverse("instances:force_off", args=[self.instance.id]),
reverse("instances:suspend", args=[self.instance.id]),
reverse("instances:resume", args=[self.instance.id]),
]
for url in endpoints:
res = self.client.get(url)
self.assertEqual(res.status_code, 405, f"GET {url} should return 405")
def test_viewer_without_ownership_cannot_power_mutate(self):
self.client.force_login(self.viewer)
endpoints = [
reverse("instances:poweron", args=[self.instance.id]),
reverse("instances:poweroff", args=[self.instance.id]),
reverse("instances:powercycle", args=[self.instance.id]),
reverse("instances:force_off", args=[self.instance.id]),
]
for url in endpoints:
res = self.client.post(url)
self.assertEqual(res.status_code, 403, f"POST {url} should be 403 for read-only viewer")
def test_owner_can_power_mutate(self):
self.client.force_login(self.owner)
with patch.object(Instance, "proxy", new_callable=lambda: self.mock_proxy):
res = self.client.post(reverse("instances:poweron", args=[self.instance.id]))
self.assertEqual(res.status_code, 302)
def test_set_root_pass_requires_is_change(self):
# Owner without is_change -> 403
self.client.force_login(self.owner)
res = self.client.post(reverse("instances:rootpasswd", args=[self.instance.id]), {"passwd": "newpass"})
self.assertEqual(res.status_code, 403)
# Viewer without ownership -> 403
self.client.force_login(self.viewer)
res_v = self.client.post(reverse("instances:rootpasswd", args=[self.instance.id]), {"passwd": "newpass"})
self.assertEqual(res_v.status_code, 403)
def test_drf_compute_pk_mismatch_returns_404(self):
other_compute = Compute.objects.create(
name="other-compute", hostname="127.0.0.2", login="root", type=1
)
self.client.force_login(self.owner)
# Query instance via wrong compute_pk in nested router
url = f"/api/v1/computes/{other_compute.id}/instances/{self.instance.id}/"
res = self.client.get(url)
self.assertEqual(res.status_code, 404)
def test_disk_media_and_snapshots_reject_get_requests(self):
self.client.force_login(self.change_user)
endpoints = [
reverse("instances:add_new_vol", args=[self.instance.id]),
reverse("instances:add_existing_vol", args=[self.instance.id]),
reverse("instances:edit_volume", args=[self.instance.id]),
reverse("instances:delete_vol", args=[self.instance.id]),
reverse("instances:detach_vol", args=[self.instance.id]),
reverse("instances:add_cdrom", args=[self.instance.id]),
reverse("instances:detach_cdrom", args=[self.instance.id, "hda"]),
reverse("instances:mount_iso", args=[self.instance.id]),
reverse("instances:unmount_iso", args=[self.instance.id]),
reverse("instances:snapshot", args=[self.instance.id]),
reverse("instances:delete_snapshot", args=[self.instance.id]),
reverse("instances:revert_snapshot", args=[self.instance.id]),
]
for url in endpoints:
res = self.client.get(url)
self.assertEqual(res.status_code, 405, f"GET {url} should return 405")
def test_disk_and_media_mutations_require_is_change(self):
# Viewer (global read-only) -> 403
self.client.force_login(self.viewer)
urls_to_test = [
reverse("instances:add_new_vol", args=[self.instance.id]),
reverse("instances:detach_cdrom", args=[self.instance.id, "hda"]),
reverse("instances:mount_iso", args=[self.instance.id]),
reverse("instances:delete_vol", args=[self.instance.id]),
]
for url in urls_to_test:
res = self.client.post(url, {})
self.assertEqual(res.status_code, 403, f"Viewer POST {url} should be 403")
# Owner without is_change (is_change=False, is_delete=False) -> 403
self.client.force_login(self.owner)
for url in urls_to_test:
res = self.client.post(url, {})
self.assertEqual(res.status_code, 403, f"Owner without is_change POST {url} should be 403")
def test_resize_views_reject_get_requests(self):
self.client.force_login(self.change_user)
endpoints = [
reverse("instances:resize_disk", args=[self.instance.id]),
reverse("instances:resizevm_cpu", args=[self.instance.id]),
reverse("instances:resize_memory", args=[self.instance.id]),
]
for url in endpoints:
res = self.client.get(url)
self.assertEqual(res.status_code, 405, f"GET {url} should return 405")
def test_resize_views_require_is_change(self):
self.client.force_login(self.viewer)
endpoints = [
reverse("instances:resize_disk", args=[self.instance.id]),
reverse("instances:resizevm_cpu", args=[self.instance.id]),
reverse("instances:resize_memory", args=[self.instance.id]),
]
for url in endpoints:
res = self.client.post(url, {})
self.assertEqual(res.status_code, 403, f"Viewer POST {url} should return 403")
self.client.force_login(self.owner)
for url in endpoints:
res = self.client.post(url, {})
self.assertEqual(res.status_code, 403, f"Owner without is_change POST {url} should return 403")
def test_get_instance_fail_closed_for_all_users_on_invalid_perm(self):
with self.assertRaises(PermissionDenied):
get_instance(self.superuser, self.instance.pk, perm_type="unknown_perm")
with self.assertRaises(PermissionDenied):
get_instance(self.owner, self.instance.pk, perm_type="unknown_perm")
def test_get_instance_staff_user_access(self):
User = get_user_model()
staff_user = User.objects.create_user(username="sec_staff", password="password", is_staff=True)
# Staff user without ownership or view_instances permission cannot view instance
with self.assertRaises(Http404):
get_instance(staff_user, self.instance.pk, perm_type="view")
# Staff user with explicit view_instances permission can view instance
view_perm = Permission.objects.get(codename="view_instances")
staff_user.user_permissions.add(view_perm)
staff_user = User.objects.get(pk=staff_user.pk)
inst = get_instance(staff_user, self.instance.pk, perm_type="view")
self.assertEqual(inst.pk, self.instance.pk)
# Staff user with view permission but without ownership cannot perform power, change, or delete operations
for perm in ["power", "change", "delete"]:
with self.assertRaises(PermissionDenied):
get_instance(staff_user, self.instance.pk, perm_type=perm)
def test_migrate_endpoint_requires_post(self):
self.client.force_login(self.superuser)
res = self.client.get(reverse("instances:migrate", args=[self.instance.id]))
self.assertEqual(res.status_code, 405)
def test_post_only_mutation_endpoints(self):
self.client.force_login(self.change_user)
# All mutation endpoints reject GET with 405 Method Not Allowed
endpoints_405 = ["change_options", "update_console", "rootpasswd", "add_public_key"]
for ep in endpoints_405:
res = self.client.get(reverse(f"instances:{ep}", args=[self.instance.id]))
self.assertEqual(res.status_code, 405, f"{ep} allowed GET request instead of 405")
def test_opposite_direction_migrations_no_deadlock(self):
import threading
import time
from instances.utils import migrate_instance
c1 = MagicMock()
c1.id = 101
c1.pk = 101
c1.hostname = "127.0.0.1"
c1.type = 1
c1.login = "root"
c1.password = ""
c2 = MagicMock()
c2.id = 102
c2.pk = 102
c2.hostname = "127.0.0.2"
c2.type = 1
c2.login = "root"
c2.password = ""
inst1 = MagicMock()
inst1.id = "inst1"
inst1.compute = c1
inst1.name = "inst1"
inst1.autostart = False
inst1.proxy = MagicMock()
inst1.uuid = "u1"
inst2 = MagicMock()
inst2.id = "inst2"
inst2.compute = c2
inst2.name = "inst2"
inst2.autostart = False
inst2.proxy = MagicMock()
inst2.uuid = "u2"
barrier = threading.Barrier(2)
errors = []
def worker_1_to_2():
try:
barrier.wait(timeout=5)
migrate_instance(c2, inst1, self.superuser)
except Exception as e:
errors.append(("worker_1_to_2", e))
def worker_2_to_1():
try:
barrier.wait(timeout=5)
migrate_instance(c1, inst2, self.superuser)
except Exception as e:
errors.append(("worker_2_to_1", e))
def slow_moveto(*args, **kwargs):
time.sleep(0.05)
with patch("instances.utils.wvmInstances") as mock_instances_cls, \
patch("instances.utils.wvmInstance"), \
patch("instances.utils.transaction.atomic"), \
patch("instances.utils.addlogmsg"), \
patch("instances.utils.Instance") as mock_instance_model:
mock_instances_cls.return_value.moveto.side_effect = slow_moveto
# under the locks each VM is still on its compute; the
# destination has no record of it
def rows(**query):
found = MagicMock(compute_id={"inst1": 101, "inst2": 102}[query["id"]]) if "id" in query else None
return MagicMock(**{"first.return_value": found})
mock_instance_model.objects.filter.side_effect = rows
t1 = threading.Thread(target=worker_1_to_2)
t2 = threading.Thread(target=worker_2_to_1)
t1.start()
t2.start()
t1.join(timeout=10)
t2.join(timeout=10)
self.assertFalse(t1.is_alive(), "Worker 1 to 2 timed out / deadlocked")
self.assertFalse(t2.is_alive(), "Worker 2 to 1 timed out / deadlocked")
self.assertEqual(errors, [], f"Unexpected errors during concurrent migrations: {errors}")
def test_resize_disk_empty_selection_warns_cleanly(self):
self.client.force_login(self.change_user)
with patch("instances.models.wvmInstance") as mock_wvm_cls:
mock_wvm_cls.return_value.get_disk_devices.return_value = []
res = self.client.post(reverse("instances:resize_disk", args=[self.instance.id]), {})
self.assertEqual(res.status_code, 302)
self.assertIn(f"/instances/{self.instance.id}/#resize", res.url)
def test_disk_mutation_denied_with_is_change(self):
# change_user has is_change=True, is_delete=False. Disk views are
# superuser-only, so is_change alone is not enough.
self.client.force_login(self.change_user)
with patch("instances.models.wvmInstance"), patch("instances.views.wvmStorage") as mock_storage:
res = self.client.post(
reverse("instances:delete_vol", args=[self.instance.id]),
{"storage": "default", "dev": "vda", "path": "/path"},
HTTP_REFERER=f"/instances/{self.instance.id}/",
)
self.assertEqual(res.status_code, 403)
mock_storage.return_value.del_volume.assert_not_called()
def test_destroy_vm_authorization(self):
# 1. User with is_change=True but is_delete=False gets 403 when trying to destroy VM
self.client.force_login(self.change_user)
res = self.client.post(reverse("instances:destroy", args=[self.instance.id]), {})
self.assertEqual(res.status_code, 403)
# 2. Staff user without ownership or is_delete cannot destroy VM
User = get_user_model()
staff_user = User.objects.create_user(username="staff_destroyer", password="password", is_staff=True)
self.client.force_login(staff_user)
res_staff = self.client.post(reverse("instances:destroy", args=[self.instance.id]), {})
self.assertEqual(res_staff.status_code, 404)
# 2b. Staff user with view_instances permission but is_delete=False gets 403
view_perm = Permission.objects.get(codename="view_instances")
staff_user.user_permissions.add(view_perm)
res_staff_view = self.client.post(reverse("instances:destroy", args=[self.instance.id]), {})
self.assertEqual(res_staff_view.status_code, 403)
# 3. Superuser can destroy VM
self.client.force_login(self.superuser)
with patch("instances.models.wvmInstance") as mock_wvm_cls:
mock_wvm_cls.return_value.get_status.return_value = 5 # shutoff
res = self.client.post(reverse("instances:destroy", args=[self.instance.id]), {})
self.assertEqual(res.status_code, 302)
self.assertFalse(Instance.objects.filter(id=self.instance.id).exists())
def test_migration_deduplicate_instances_logic(self):
import importlib
migration_mod = importlib.import_module("instances.migrations.0012_instance_unique_compute_uuid")
dedup_fn = getattr(migration_mod, "deduplicate_instances")
mock_apps = MagicMock()
mock_instance_model = MagicMock()
mock_userinstance_model = MagicMock()
def get_model(app_label, model_name):
if model_name == "Instance":
return mock_instance_model
elif model_name == "UserInstance":
return mock_userinstance_model
return MagicMock()
mock_apps.get_model = get_model
empty_inst = MagicMock(uuid="")
primary_inst = MagicMock(id=1)
dup_inst = MagicMock(id=2)
def mock_inst_filter(*args, **kwargs):
if args:
# Called for empty_uuid_instances query
return [empty_inst]
# Called with compute_id and uuid
ret = MagicMock()
ret.order_by.return_value = [primary_inst, dup_inst]
return ret
mock_instance_model.objects.filter.side_effect = mock_inst_filter
mock_instance_model.objects.exclude.return_value.exclude.return_value.values.return_value.annotate.return_value.filter.return_value = [
{"compute_id": 1, "uuid": "test-uuid-1234"}
]
primary_ui = MagicMock(is_change=False, is_delete=False, is_vnc=False)
dup_ui = MagicMock(user="user1", is_change=True, is_delete=False, is_vnc=True)
mock_userinstance_model.objects.filter.side_effect = lambda **kwargs: (
[dup_ui] if kwargs.get("instance") == dup_inst else
MagicMock(first=lambda: primary_ui)
)
dedup_fn(mock_apps, None)
self.assertTrue(len(empty_inst.uuid) > 0)
empty_inst.save.assert_called_once_with(update_fields=['uuid'])
dup_inst.delete.assert_called_once()
dup_ui.delete.assert_called_once()
self.assertTrue(primary_ui.is_change)
self.assertTrue(primary_ui.is_vnc)
self.assertFalse(primary_ui.is_delete)
primary_ui.save.assert_called_once()
def test_unique_compute_uuid_db_constraint_enforced(self):
from django.db import IntegrityError
with self.assertRaises(IntegrityError):
Instance.objects.create(
compute=self.compute,
name="duplicate_vm",
uuid=self.instance.uuid,
)
def test_busy_instance_redirects_without_executing_the_operation(self):
self.client.force_login(self.owner)
with patch("instances.views.libvirt_instance_lock", side_effect=TimeoutError("busy")), patch(
"instances.models.wvmInstance"
) as proxy:
response = self.client.post(reverse("instances:poweron", args=[self.instance.pk]), {})
self.assertRedirects(response, reverse("instances:instance", args=[self.instance.pk]), fetch_redirect_response=False)
proxy.assert_not_called()

View file

@ -0,0 +1,172 @@
"""Every libvirt state has a label, and the lists offer the actions the state
and the user's permissions allow."""
from types import SimpleNamespace
from unittest.mock import PropertyMock, patch
from accounts.models import UserInstance
from appsettings.models import AppSettings
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from instances.states import allowed_actions
LABELS = {0: "No state", 1: "Active", 2: "Blocked", 3: "Suspended", 4: "Shutting down", 5: "Off", 6: "Crashed", 7: "PM suspended"}
# actions offered per state, for a superuser
ACTIONS = {
0: set(),
1: {"poweroff", "powercycle", "suspend"},
2: {"poweroff", "powercycle", "suspend"},
3: {"resume", "force_off"},
4: {"force_off"},
5: {"poweron"},
6: {"force_off"},
7: {"force_off"},
}
ALL = {"poweron", "poweroff", "powercycle", "force_off", "suspend", "resume"}
class Domain:
def __init__(self, state):
self.state = state
def info(self):
return [self.state, 4194304, 2097152, 2, 0]
class StateTests(TestCase):
def setUp(self):
User = get_user_model()
self.admin = User.objects.create_superuser("st-admin", "st@example.com", "pw")
self.owner = User.objects.create_user("st-owner", password="pw")
self.viewer = User.objects.create_user("st-viewer", password="pw")
self.viewer.user_permissions.add(Permission.objects.get(codename="view_instances"))
self.compute = Compute.objects.create(name="st", hostname="10.0.0.1", login="u", password="p", type=1)
self.vms = {}
for state in LABELS:
vm = Instance.objects.create(compute=self.compute, name=f"st-vm-{state}", uuid=f"{state:08d}-0000-0000-0000-000000000000")
UserInstance.objects.create(user=self.owner, instance=vm)
self.vms[state] = vm
AppSettings.objects.filter(key="VIEW_INSTANCES_LIST_STYLE").update(value="nongrouped")
def get(self, user, url):
by_uuid = {vm.uuid: state for state, vm in self.vms.items()}
def wvm(*args, uuid=None, **kwargs):
return SimpleNamespace(instance=Domain(by_uuid[uuid]), get_title=lambda: "", get_uuid=lambda: uuid)
self.client.force_login(user)
props = {"status": True, "connection_error": None, "cpu_count": 1, "ram_size": 1, "ram_usage": 0}
patches = [patch.object(Compute, k, new_callable=PropertyMock, return_value=v) for k, v in props.items()]
patches += [patch("instances.views.utils.refr"), patch("computes.views.utils.refresh_instance_database"),
patch("instances.models.wvmInstance", side_effect=wvm)]
for p in patches:
p.start()
try:
response = self.client.get(url)
finally:
for p in reversed(patches):
p.stop()
self.assertEqual(response.status_code, 200)
return response.content.decode()
def offered(self, page, vm):
return {a for a in ALL if reverse(f"instances:{a}", args=[vm.id]) in page}
def test_every_state_has_a_label(self):
page = self.get(self.admin, reverse("instances:index"))
for state, label in LABELS.items():
with self.subTest(state=state):
self.assertIn(f">{label}<", page)
def test_superuser_actions_follow_the_state(self):
for url in (reverse("instances:index"), reverse("instances", args=[self.compute.id])):
page = self.get(self.admin, url)
for state, vm in self.vms.items():
with self.subTest(url=url, state=state):
self.assertEqual(self.offered(page, vm), ACTIONS[state])
def test_owner_is_not_offered_suspend_or_resume(self):
# both views are for superusers only; a VM an administrator suspended
# stays as it is for its owner, as on the VM page
page = self.get(self.owner, reverse("instances:index"))
for state, vm in self.vms.items():
with self.subTest(state=state):
expected = set() if state == 3 else ACTIONS[state] - {"suspend", "resume"}
self.assertEqual(self.offered(page, vm), expected)
def test_a_viewer_who_owns_nothing_is_offered_no_actions(self):
page = self.get(self.viewer, reverse("instances:index"))
for state, vm in self.vms.items():
with self.subTest(state=state):
self.assertIn(vm.name, page)
self.assertEqual(self.offered(page, vm), set())
class DetailStateTests(TestCase):
"""The VM page names every state and offers a forced power off where only that helps."""
def test_states(self):
owner = get_user_model().objects.create_user("st-detail-owner", password="pw")
compute = Compute.objects.create(name="st-d", hostname="10.0.0.2", login="u", password="p", type=1)
vm = Instance.objects.create(compute=compute, name="st-d-vm", uuid="99999999-0000-0000-0000-00000000d000")
UserInstance.objects.create(user=owner, instance=vm, is_change=True)
self.client.force_login(owner)
badge = LABELS
force_off = reverse("instances:force_off", args=[vm.id])
poweroff = reverse("instances:poweroff", args=[vm.id])
for state, label in badge.items():
with self.subTest(state=state), patch("instances.models.wvmInstance") as wvm, patch.object(
Compute, "status", new_callable=PropertyMock, return_value=True
):
proxy = wvm.return_value
proxy.get_memory.return_value = 1024
proxy.get_cur_memory.return_value = 1024
proxy.get_max_memory.return_value = 4096
for name in ("get_networks", "get_ifaces", "get_storages", "get_disk_devices", "get_media_devices", "get_net_devices"):
getattr(proxy, name).return_value = []
proxy.get_status.return_value = state
page = self.client.get(reverse("instances:instance", args=[vm.id])).content.decode()
self.assertIn(f'">{label}</span>', page.replace("\n", "").replace(" ", ""))
self.assertEqual(poweroff in page, state in (1, 2))
self.assertEqual(force_off in page, state in (1, 2, 4, 6, 7))
class AllowedActionsTests(TestCase):
"""The rules themselves, without templates."""
def test_rules(self):
User = get_user_model()
admin = User.objects.create_superuser("aa-admin", "aa@example.com", "pw")
owner = User.objects.create_user("aa-owner", password="pw")
other = User.objects.create_user("aa-other", password="pw")
compute = Compute.objects.create(name="aa", hostname="10.0.0.3", login="u", password="p", type=1)
vm = Instance.objects.create(compute=compute, name="aa-vm", uuid="aaaaaaaa-0000-0000-0000-000000000000")
UserInstance.objects.create(user=owner, instance=vm)
for state in LABELS:
with self.subTest(state=state):
self.assertEqual(allowed_actions(admin, vm, state) - {"console"}, ACTIONS[state])
expected = set() if state == 3 else ACTIONS[state] - {"suspend", "resume"}
self.assertEqual(allowed_actions(owner, vm, state) - {"console"}, expected)
self.assertEqual(allowed_actions(other, vm, state), set())
class TemplateCloneTests(TestCase):
"""A shut-off template offers Clone to whoever may clone it, owner or not."""
def test_clone_link(self):
User = get_user_model()
compute = Compute.objects.create(name="tc", hostname="10.0.0.4", login="u", password="p", type=1)
vm = Instance.objects.create(compute=compute, name="tc-vm", uuid="cccccccc-0000-0000-0000-000000000000", is_template=True)
cloner = User.objects.create_user("tc-viewer", password="pw")
cloner.user_permissions.add(*Permission.objects.filter(codename__in=["view_instances", "clone_instances"]))
cloner = User.objects.get(pk=cloner.pk) # no cached permissions
owner = User.objects.create_user("tc-owner", password="pw")
UserInstance.objects.create(user=owner, instance=vm)
admin = User.objects.create_superuser("tc-admin", "tc@example.com", "pw")
self.assertEqual(allowed_actions(cloner, vm, 5), {"clone"})
self.assertEqual(allowed_actions(admin, vm, 5), {"clone"})
self.assertEqual(allowed_actions(owner, vm, 5), set()) # no clone permission

View file

@ -0,0 +1,194 @@
"""The VM stats: each answer carries a signed usage sample bound to the VM on
its compute; the next poll sends it back so that the rates are averages since
then, without waiting."""
import json
import shutil
import subprocess
import unittest
from unittest.mock import patch
import libvirt
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.core import signing
from django.test import TestCase
from django.urls import reverse
from lxml import html
from instances.models import Instance
from vrtManager.instance import USAGE_MAX_WINDOW
SAMPLE = {"key": [7, 4, ["vda"], [["52:54:00:00:00:01", "vnet0"]]], "counters": [1, [[2, 3]], [[4, 5]], 100.0]}
class StatsViewTestCase(TestCase):
def setUp(self):
self.compute = Compute.objects.create(name="stats", hostname="192.0.2.1", login="u", password="p", type=1)
self.other_compute = Compute.objects.create(name="stats2", hostname="192.0.2.2", login="u", password="p", type=1)
uuid = "5d1b8a3e-0000-4000-8000-000000000001"
self.vm = Instance.objects.create(compute=self.compute, name="stats-vm", uuid=uuid)
self.other = Instance.objects.create(compute=self.compute, name="stats-vm2", uuid=uuid.replace("1", "2"))
self.client.force_login(get_user_model().objects.create_superuser("sv-admin", "sv@example.com", "pw"))
patcher = patch("instances.models.wvmInstance")
self.addCleanup(patcher.stop)
self.proxy = patcher.start().return_value
self.proxy.mem_usage.return_value = {"used": 1, "total": 2}
self.proxy.usage.return_value = {
"cpu": 12.345,
"disks": [{"dev": "vda", "rd": 2_000_000, "wr": None}],
"nics": [{"dev": 0, "rx": 8_000_000, "tx": 0}],
"window": 9.96,
"sample": SAMPLE,
}
def stats(self, vm=None, **params):
response = self.client.get(reverse("instances:stats", args=[(vm or self.vm).id]), params)
self.assertEqual(response.status_code, 200)
return json.loads(response.content)
def previous(self):
return self.proxy.usage.call_args.args[0]
def test_rates_in_mb_and_mbit_per_second_and_the_sample_round_trip(self):
data = self.stats()
self.assertIsNone(self.previous())
self.assertEqual((data["cpudata"], data["window"]), (12.3, 10.0))
self.assertEqual(data["blkdata"], [{"dev": "vda", "data": [2.0, None]}])
self.assertEqual(data["netdata"], [{"dev": 0, "data": [8.0, 0.0]}])
self.stats(sample=data["sample"])
self.assertEqual(self.previous(), SAMPLE)
def test_an_altered_old_or_foreign_sample_is_not_used(self):
token = self.stats()["sample"]
foreign = self.stats(self.other)["sample"]
altered = token[:-2] + ("xx" if not token.endswith("xx") else "yy")
for name, sample in (("altered", altered), ("garbage", "x"), ("other VM", foreign)):
with self.subTest(name):
self.stats(sample=sample)
self.assertIsNone(self.previous())
with patch("django.core.signing.time.time", return_value=signing.time.time() + USAGE_MAX_WINDOW + 1):
self.stats(sample=token)
self.assertIsNone(self.previous())
def test_a_sample_from_before_a_migration_is_not_used(self):
token = self.stats()["sample"]
Instance.objects.filter(pk=self.vm.pk).update(compute=self.other_compute)
self.stats(sample=token)
self.assertIsNone(self.previous())
def test_a_vm_that_is_not_running_gives_no_sample(self):
self.proxy.usage.return_value = {"cpu": 0, "disks": [], "nics": []}
data = self.stats()
self.assertEqual(data["cpudata"], 0)
self.assertNotIn("sample", data)
self.assertNotIn("window", data)
# a VM with a disk and a NIC, on libvirt's test driver
DOMAIN = """<domain type='test'><name>stats-script-vm</name><uuid>3c0e2b7a-91d4-4f5e-8a6b-0d2f4e6a8c10</uuid>
<memory unit='MiB'>128</memory><vcpu>1</vcpu><os><type arch='i686'>hvm</type></os>
<devices><disk type='file' device='disk'><source file='/default-pool/stats-script.img'/><target dev='vda' bus='virtio'/></disk>
<interface type='network'><mac address='52:54:00:00:00:31'/><source network='default'/><model type='virtio'/></interface></devices>
</domain>"""
class TestDriverVM:
def setUp(self):
self.conn = libvirt.open("test:///default")
self.addCleanup(self.conn.close)
# the test host lives on while a libvirt object still refers to it
pool = self.conn.storagePoolLookupByName("default-pool")
if "stats-script.img" not in pool.listVolumes():
pool.createXML("<volume><name>stats-script.img</name><capacity>1048576</capacity></volume>", 0)
self.domain = self.conn.defineXML(DOMAIN)
compute = Compute.objects.create(name="ss", hostname="localhost", login="", password="", type=4)
self.vm = Instance.objects.create(compute=compute, name=self.domain.name(), uuid=self.domain.UUIDString())
self.client.force_login(get_user_model().objects.create_superuser("ss-admin", "ss@example.com", "pw"))
for target, value in (
("vrtManager.connection.connection_manager.get_connection", self.conn),
("vrtManager.connection.wvmConnect.get_machine_types", ["pc"]),
("vrtManager.connection.wvmConnect.get_nwfilters", []),
):
patcher = patch(target, return_value=value)
patcher.start()
self.addCleanup(patcher.stop)
class SampleRoundTripTestCase(TestDriverVM, TestCase):
def test_a_real_sample_is_used_by_the_next_poll(self):
self.domain.create()
self.addCleanup(self.domain.destroy)
url = reverse("instances:stats", args=[self.vm.id])
with patch("vrtManager.instance.time.sleep") as sleep:
first = json.loads(self.client.get(url).content)
sleep.assert_called_once_with(1)
sleep.reset_mock()
second = json.loads(self.client.get(url, {"sample": first["sample"]}).content)
sleep.assert_not_called()
self.assertEqual([disk["dev"] for disk in second["blkdata"]], ["vda"])
self.assertIn("sample", second)
@unittest.skipUnless(shutil.which("node"), "node is not installed")
class StatsScriptTestCase(TestDriverVM, TestCase):
"""The VM page's script sends each answer's sample with the next poll and
drops it after a failed one."""
def page(self):
response = self.client.get(reverse("instances:instance", args=[self.vm.id]))
self.assertEqual(response.status_code, 200)
return response.content.decode()
def test_the_next_poll_sends_the_previous_sample(self):
script = next(s for s in html.fromstring(self.page()).xpath("//script[not(@src)]/text()") if "statsSample" in s)
js = """
const vm = require("vm");
const charts = [], requests = [], handlers = {};
let poll, fail = false;
const canvas = {get: () => ({getContext: () => ({})})};
const $ = () => canvas;
$.getJSON = (url, params) => {
requests.push(params);
return {fail: (callback) => { if (fail) callback(); return {}; }};
};
const page = {
$,
document: {querySelector: () => ({addEventListener: (name, handler) => { handlers[name] = handler; }})},
// Chart.js adds the lists a config leaves out
Chart: function (ctx, config) {
this.data = Object.assign({labels: []}, config.data);
this.data.datasets.forEach((set) => { set.data = set.data || []; });
this.options = config.options;
this.update = () => {};
charts.push(this);
},
pollWhileVisible: (interval, request, onData, first) => { poll = {interval, first, request, onData}; return {}; },
};
vm.runInNewContext(SCRIPT, vm.createContext(page));
handlers["shown.bs.tab"]();
const answer = (cpu, sample) => ({cpudata: cpu, window: 9.9, sample: sample, timeline: "t",
memdata: {used: 0, total: 1024},
// vdb was attached after the page loaded
blkdata: [{dev: "vdb", data: [9, 9]}, {dev: "vda", data: [1.5, null]}],
netdata: [{dev: 0, data: [2, 3]}]});
poll.request();
poll.onData(answer(3, "token-1"));
poll.request();
fail = true;
poll.request();
fail = false;
poll.request();
const label = charts[0].options.tooltips.callbacks.label({datasetIndex: 0, index: 0, yLabel: 3}, charts[0].data);
console.log(JSON.stringify({requests, label, every: [poll.interval, poll.first], cpu: charts[0].data.datasets[0].data,
disk: charts[2].data.datasets[1].data, net: charts[3].data.datasets[0].data}));
""".replace("SCRIPT", json.dumps(script))
out = subprocess.run(["node", "-e", js], capture_output=True, text=True, timeout=30)
self.assertEqual(out.returncode, 0, out.stderr)
result = json.loads(out.stdout)
# the first poll at once, then every 5 s
self.assertEqual(result["every"], [5000, 0])
# the sample goes with the next poll; a failed poll drops it
self.assertEqual(result["requests"], [{}, {"sample": "token-1"}, {"sample": "token-1"}, {}])
# a disk without a chart is skipped, the other charts still update
self.assertEqual((result["cpu"], result["disk"], result["net"]), ([3], [None], [2]))
self.assertTrue(result["label"].endswith(": 3 % (average over 9.9 s)"), result["label"])

View file

@ -0,0 +1,76 @@
"""
Only superusers and staff may mark or unmark a VM as a template.
The UI only disables the checkbox for other users, and a disabled checkbox is
not submitted, so the server must not derive is_template from its absence for
them.
"""
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
class TemplateFlagTestCase(TestCase):
def setUp(self):
User = get_user_model()
self.superuser = User.objects.create_superuser(
username="tpl_super", email="tpl_super@example.com", password="x"
)
self.owner = User.objects.create_user(username="tpl_owner", password="x")
self.staff_owner = User.objects.create_user(
username="tpl_staff_owner", password="x", is_staff=True
)
self.compute = Compute.objects.create(
name="tpl-compute", hostname="127.0.0.1:1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="tpl-vm",
uuid="dddddddd-eeee-ffff-0000-111111111111",
)
for user in (self.owner, self.staff_owner):
UserInstance.objects.create(instance=self.instance, user=user, is_change=True)
def _change_options(self, user, data, status=302):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as wvm:
# unmarking a template checks the owner's quota with the VM's size
wvm.return_value.get_vcpu.return_value = 1
wvm.return_value.get_memory.return_value = 1024
wvm.return_value.get_disk_devices.return_value = []
res = self.client.post(
reverse("instances:change_options", args=[self.instance.id]), data
)
self.assertEqual(res.status_code, status)
self.instance.refresh_from_db()
def _make_template(self):
self.instance.is_template = True
self.instance.save(update_fields=["is_template"])
def test_owner_cannot_mark_vm_as_template(self):
self._change_options(self.owner, {"title": "t", "is_template": "True"})
self.assertFalse(self.instance.is_template)
def test_owner_cannot_change_a_template(self):
# a template is changed only by superusers and staff owners
self._make_template()
self._change_options(self.owner, {"title": "new title", "description": ""}, status=403)
self.assertTrue(self.instance.is_template)
def test_staff_owner_can_mark_and_unmark_template(self):
self._change_options(self.staff_owner, {"title": "t", "is_template": "True"})
self.assertTrue(self.instance.is_template)
# An unchecked checkbox is not submitted: for staff that means "not a template".
self._change_options(self.staff_owner, {"title": "t"})
self.assertFalse(self.instance.is_template)
def test_superuser_can_unmark_template(self):
self._make_template()
self._change_options(self.superuser, {"title": "t"})
self.assertFalse(self.instance.is_template)

View file

@ -0,0 +1,68 @@
"""Templates do not count towards the quota and cannot be started. Turning a
template back into a VM adds it to its owner's usage, so for users with a
quota it is checked like any other increase."""
from unittest.mock import patch
from accounts.models import UserInstance
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.contrib.messages import get_messages
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
from instances.utils import QUOTA_UNVERIFIED
class TemplateFlagQuotaTests(TestCase):
def setUp(self):
User = get_user_model()
self.staff = User.objects.create_user("tq-staff", password="pw", is_staff=True)
compute = Compute.objects.create(name="tq", hostname="10.0.0.5", login="u", password="p", type=1)
self.vm = Instance.objects.create(compute=compute, name="tq-vm", uuid="12345678-0000-0000-0000-00000000aaaa")
UserInstance.objects.create(user=self.staff, instance=self.vm, is_change=True)
def post(self, user, is_template, quota=""):
self.client.force_login(user)
data = {"title": "", "description": ""}
if is_template:
data["is_template"] = "on"
with patch("instances.models.wvmInstance") as wvm, patch(
"instances.views.utils.check_user_quota", return_value=quota
) as check:
wvm.return_value.get_vcpu.return_value = 2
wvm.return_value.get_memory.return_value = 2048
wvm.return_value.get_disk_devices.return_value = [{"size": 10 << 30}]
response = self.client.post(reverse("instances:change_options", args=[self.vm.id]), data)
self.vm.refresh_from_db()
return check, [str(m) for m in get_messages(response.wsgi_request)]
def test_making_a_template_needs_no_quota(self):
check, _ = self.post(self.staff, is_template=True)
self.assertTrue(self.vm.is_template)
check.assert_not_called()
def test_turning_a_template_into_a_vm_is_checked(self):
Instance.objects.filter(pk=self.vm.pk).update(is_template=True)
check, _ = self.post(self.staff, is_template=False)
self.assertFalse(self.vm.is_template)
check.assert_called_once_with(self.staff, 1, 2, 2048, 10)
def test_over_quota_the_template_stays_a_template(self):
Instance.objects.filter(pk=self.vm.pk).update(is_template=True)
_, messages = self.post(self.staff, is_template=False, quota="cpu")
self.assertTrue(self.vm.is_template)
self.assertTrue(any("quota" in m for m in messages), messages)
def test_an_unverifiable_quota_keeps_it_a_template(self):
Instance.objects.filter(pk=self.vm.pk).update(is_template=True)
_, messages = self.post(self.staff, is_template=False, quota=QUOTA_UNVERIFIED)
self.assertTrue(self.vm.is_template)
self.assertTrue(any("cannot be reached" in m for m in messages), messages)
def test_superusers_have_no_quota(self):
Instance.objects.filter(pk=self.vm.pk).update(is_template=True)
admin = get_user_model().objects.create_superuser("tq-admin", "tq@example.com", "pw")
check, _ = self.post(admin, is_template=False, quota="cpu")
self.assertFalse(self.vm.is_template)
check.assert_not_called()

View file

@ -0,0 +1,64 @@
"""
A template is not started (power on or power cycle, web or API) and is
changed or deleted only by superusers and staff owners.
"""
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from rest_framework.test import APIClient
from accounts.models import UserInstance
from computes.models import Compute
from instances.models import Instance
class TemplateRulesTestCase(TestCase):
def setUp(self):
compute = Compute.objects.create(name="tpl-c", hostname="192.0.2.5", login="root", password="", type=1)
self.template = Instance.objects.create(
compute=compute, name="tpl-vm", uuid="ffffffff-0000-1111-2222-333333333333", is_template=True
)
self.owner = get_user_model().objects.create_user("tpl_owner", password="x")
UserInstance.objects.create(instance=self.template, user=self.owner, is_delete=True)
self.staff = get_user_model().objects.create_user("tpl_staff", password="x", is_staff=True)
UserInstance.objects.create(instance=self.template, user=self.staff, is_delete=True)
def test_power_cycle_does_not_start_a_template(self):
api = APIClient()
api.force_login(self.owner)
self.client.force_login(self.owner)
for post in (
lambda: self.client.post(reverse("instances:powercycle", args=[self.template.id])),
lambda: api.post(reverse("compute-instance-powercycle", args=[self.template.compute_id, self.template.id])),
):
with patch("instances.models.wvmInstance") as wvm:
post()
self.assertFalse(wvm.return_value.start.called)
self.assertFalse(wvm.return_value.force_shutdown.called)
def test_only_staff_owners_delete_a_template(self):
self.client.force_login(self.owner)
with patch("instances.models.wvmInstance") as wvm:
response = self.client.post(reverse("instances:destroy", args=[self.template.id]))
self.assertEqual(response.status_code, 403)
self.assertFalse(wvm.return_value.delete.called)
self.client.force_login(self.staff)
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.instance.isActive.return_value = False
self.client.post(reverse("instances:destroy", args=[self.template.id]))
self.assertTrue(wvm.return_value.delete.called)
def test_the_destroy_confirmation_page_offers_the_form_to_who_may_delete(self):
url = reverse("instances:destroy", args=[self.template.id])
superuser = get_user_model().objects.create_superuser("tpl_root", "r@example.com", "x")
for user, status, form in ((superuser, 200, True), (self.staff, 200, True), (self.owner, 403, False)):
with self.subTest(user=user.username):
self.client.force_login(user)
with patch("instances.models.wvmInstance") as wvm:
wvm.return_value.get_status.return_value = 5
response = self.client.get(url)
self.assertEqual(response.status_code, status)
self.assertEqual('id="delete_form"' in response.content.decode(), form)

View file

@ -0,0 +1,27 @@
from unittest.mock import patch
from computes.models import Compute
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from instances.models import Instance
class UpdateConsoleTestCase(TestCase):
def setUp(self):
admin = get_user_model().objects.create_superuser("console_admin", "c@example.com", "pw")
self.client.force_login(admin)
compute = Compute.objects.create(name="console-compute", hostname="127.0.0.1", login="", password="", type=4)
self.instance = Instance.objects.create(
compute=compute, name="console-vm", uuid="11111111-2222-3333-4444-555555555555"
)
def post(self, data):
with patch("instances.models.wvmInstance") as wvm:
self.client.post(reverse("instances:update_console", args=[self.instance.id]), data)
return wvm.return_value
def test_console_settings_are_applied(self):
proxy = self.post({"listen_on": "127.0.0.1", "password": "", "keymap": "de"})
proxy.set_console_keymap.assert_called_once_with("de")
proxy.set_console_listener_addr.assert_called_once_with("127.0.0.1")

File diff suppressed because it is too large Load diff

167
instances/tests/test_xss.py Normal file
View file

@ -0,0 +1,167 @@
"""
JSON endpoints must not be served as text/html (reflected XSS), and
templates must not build HTML by concatenating server data that contains
user-controlled names (stored XSS).
"""
import re
from pathlib import Path
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from accounts.models import UserInstance, UserSSHKey
from computes.models import Compute
from instances.models import Instance
ROOT = Path(__file__).resolve().parent.parent.parent
PAYLOAD = "<script>alert(1)</script>"
class JsonEndpointContentTypeTestCase(TestCase):
def setUp(self):
User = get_user_model()
self.superuser = User.objects.create_superuser(
username="xss_super", email="xss_super@example.com", password="password"
)
self.compute = Compute.objects.create(
name="xss-compute", hostname="127.0.0.1", login="root", password="", type=1
)
self.instance = Instance.objects.create(
compute=self.compute,
name="xss-vm",
uuid="99999999-8888-7777-6666-555555555555",
)
UserInstance.objects.create(instance=self.instance, user=self.superuser)
UserSSHKey.objects.create(
user=self.superuser,
keyname="k",
keypublic=f"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI {PAYLOAD}",
)
self.client.force_login(self.superuser)
def assertJson(self, response):
self.assertEqual(response.status_code, 200)
self.assertEqual(response["Content-Type"], "application/json")
def test_guess_mac_address_reflects_vname_as_json(self):
res = self.client.get(
reverse("instances:guess_mac_address", args=["<img src=x onerror=alert(1)>"])
)
self.assertJson(res)
def test_random_mac_address_is_json(self):
self.assertJson(self.client.get(reverse("instances:random_mac_address")))
def test_guess_clone_name_is_json(self):
self.assertJson(self.client.get(reverse("instances:guess_clone_name")))
def test_sshkeys_is_json(self):
self.assertJson(
self.client.get(reverse("instances:sshkeys", args=[self.instance.id]))
)
def test_sshkeys_plain_is_text_plain(self):
res = self.client.get(
reverse("instances:sshkeys", args=[self.instance.id]) + "?plain=true"
)
self.assertEqual(res.status_code, 200)
self.assertTrue(res["Content-Type"].startswith("text/plain"))
def test_storage_volumes_is_json(self):
with patch("storages.views.wvmStorage") as mock_storage:
mock_storage.return_value.get_volumes.return_value = [PAYLOAD]
res = self.client.get(
reverse("volumes", args=[self.compute.id, "default"])
)
self.assertJson(res)
def test_datasource_metadata_is_json(self):
self.assertJson(
self.client.get(reverse("ds_openstack_metadata", args=["latest"]))
)
def test_compute_json_endpoints_are_json(self):
urls = [
reverse("compute_graph", args=[self.compute.id]),
reverse("machines", args=[self.compute.id, "x86_64"]),
reverse("buses", args=[self.compute.id, "x86_64", "q35", "disk"]),
reverse("domcaps", args=[self.compute.id, "x86_64", "q35"]),
]
with patch("computes.views.ComputeManager") as mock_mgr:
for method in ("compute_graph", "get_machine_types", "get_disk_buses", "get_dom_capabilities"):
getattr(mock_mgr.return_value, method).return_value = "{}"
for url in urls:
with self.subTest(url=url):
self.assertJson(self.client.get(url))
def test_vm_logs_is_json(self):
self.assertJson(self.client.get(reverse("vm_logs", args=[self.instance.name])))
class TemplateHtmlConcatenationTestCase(TestCase):
"""
The log table and the volume dropdown are filled by JavaScript from JSON
that contains user-entered names. They must use DOM APIs (.text()/.val())
instead of concatenating the values into an HTML string.
"""
def _read(self, relative):
return (ROOT / relative).read_text()
def test_logs_table_does_not_concatenate_log_fields_into_html(self):
src = self._read("instances/templates/instances/stats_tab.html")
for field in ("date", "user", "message"):
self.assertNotIn(f"+row['{field}']+", src)
self.assertNotIn('$("#logs_table > tbody").html(', src)
def test_volume_dropdown_does_not_concatenate_volume_names_into_html(self):
src = self._read("instances/templates/instance.html")
self.assertNotIn("'<option value=' + item", src)
self.assertNotIn('pool + "<span', src)
def test_create_wizard_chipset_list_does_not_concatenate_into_html(self):
src = self._read("instances/templates/create_instance_w1.html")
self.assertNotIn("""append('<option value="' + item""", src)
def test_create_wizard_volume_lists_do_not_concatenate_volume_names_into_html(self):
src = self._read("instances/templates/create_instance_w2.html")
self.assertNotIn("'<option value=' + item", src)
# Every template line that builds HTML from JavaScript must be listed here with
# a reason; a new one fails the test and has to be reviewed (use .text() /
# .val() / DOM APIs for server data instead).
HTML_SINK = re.compile(r"""\.html\(|innerHTML\s*=|append\(\s*['"]<""")
ALLOWED_HTML_SINKS = {
("accounts/templates/login.html", "$btn.html("): "static spinner markup",
("accounts/templates/accounts/otp_login.html", "$btn.html("): "static spinner markup",
("console/templates/console-xterm.html", "status.innerHTML = '<span style=\"background-color: lightgreen;\">connected</span>'"): "static text",
("console/templates/console-xterm.html", "button.innerHTML = 'Disconnect'"): "static text",
("console/templates/console-xterm.html", "status.innerHTML = '<span style=\"background-color: #ff8383;\">disconnected</span>'"): "static text",
("console/templates/console-xterm.html", "button.innerHTML = 'Connect'"): "static text",
("console/templates/console-xterm.html", "if (button.innerHTML =='Connect'){"): "comparison, not a write",
("console/templates/console-xterm.html", 'else if (button.innerHTML == "Disconnect"){'): "comparison, not a write",
("instances/templates/create_instance_w2.html", "$('#img-list').html(selected_list_html);"): "superuser-only; tracked as U-04",
("instances/templates/create_instance_w2.html", "$('#net-list').html(selected_list_html);"): "superuser-only; tracked as U-04",
("instances/templates/instance.html", "//sto_input.innerHTML = pool;"): "comment",
}
class TemplateHtmlSinkInventoryTestCase(TestCase):
def test_every_html_sink_in_templates_is_reviewed(self):
found = set()
for path in ROOT.glob("*/templates/**/*.html"):
rel = str(path.relative_to(ROOT))
for line in path.read_text().splitlines():
if HTML_SINK.search(line):
found.add((rel, line.strip()))
templates_root = ROOT / "templates"
for path in templates_root.glob("**/*.html"):
rel = str(path.relative_to(ROOT))
for line in path.read_text().splitlines():
if HTML_SINK.search(line):
found.add((rel, line.strip()))
self.assertEqual(sorted(found - set(ALLOWED_HTML_SINKS)), [], "unreviewed HTML sinks")
self.assertEqual(sorted(set(ALLOWED_HTML_SINKS) - found), [], "stale allowlist entries")