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:
parent
0906838193
commit
c55f52f025
154 changed files with 27 additions and 39 deletions
0
instances/tests/__init__.py
Normal file
0
instances/tests/__init__.py
Normal file
127
instances/tests/livetest.py
Normal file
127
instances/tests/livetest.py
Normal 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()
|
||||
57
instances/tests/test_change_network.py
Normal file
57
instances/tests/test_change_network.py
Normal 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")
|
||||
32
instances/tests/test_change_xml.py
Normal file
32
instances/tests/test_change_xml.py
Normal 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)))
|
||||
54
instances/tests/test_clone_disks.py
Normal file
54
instances/tests/test_clone_disks.py
Normal 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)
|
||||
235
instances/tests/test_clone_permission.py
Normal file
235
instances/tests/test_clone_permission.py
Normal 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")
|
||||
98
instances/tests/test_console_listener.py
Normal file
98
instances/tests/test_console_listener.py
Normal 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)
|
||||
78
instances/tests/test_console_rule.py
Normal file
78
instances/tests/test_console_rule.py
Normal 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)
|
||||
87
instances/tests/test_console_settings_access.py
Normal file
87
instances/tests/test_console_settings_access.py
Normal 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")
|
||||
114
instances/tests/test_create_dialog_cpu.py
Normal file
114
instances/tests/test_create_dialog_cpu.py
Normal 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)
|
||||
146
instances/tests/test_create_instance.py
Normal file
146
instances/tests/test_create_instance.py
Normal 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)
|
||||
48
instances/tests/test_create_rollback.py
Normal file
48
instances/tests/test_create_rollback.py
Normal 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()
|
||||
36
instances/tests/test_create_wizard_url.py
Normal file
36
instances/tests/test_create_wizard_url.py
Normal 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)
|
||||
87
instances/tests/test_destroy.py
Normal file
87
instances/tests/test_destroy.py
Normal 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())
|
||||
109
instances/tests/test_detail_reads.py
Normal file
109
instances/tests/test_detail_reads.py
Normal 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")
|
||||
45
instances/tests/test_detail_unreachable.py
Normal file
45
instances/tests/test_detail_unreachable.py
Normal 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])
|
||||
358
instances/tests/test_disk_isolation.py
Normal file
358
instances/tests/test_disk_isolation.py
Normal 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], "")
|
||||
28
instances/tests/test_drbd_target.py
Normal file
28
instances/tests/test_drbd_target.py
Normal 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)
|
||||
142
instances/tests/test_error_handling.py
Normal file
142
instances/tests/test_error_handling.py
Normal 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())
|
||||
502
instances/tests/test_gstfsd.py
Normal file
502
instances/tests/test_gstfsd.py
Normal 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")
|
||||
44
instances/tests/test_index.py
Normal file
44
instances/tests/test_index.py
Normal 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()), [])
|
||||
63
instances/tests/test_index_host_alerts.py
Normal file
63
instances/tests/test_index_host_alerts.py
Normal 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")
|
||||
86
instances/tests/test_list_rpc.py
Normal file
86
instances/tests/test_list_rpc.py
Normal 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")
|
||||
107
instances/tests/test_list_unreachable.py
Normal file
107
instances/tests/test_list_unreachable.py
Normal 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)
|
||||
117
instances/tests/test_live_clone.py
Normal file
117
instances/tests/test_live_clone.py
Normal 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())
|
||||
198
instances/tests/test_live_create.py
Normal file
198
instances/tests/test_live_create.py
Normal 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"))
|
||||
|
||||
542
instances/tests/test_live_dataloss.py
Normal file
542
instances/tests/test_live_dataloss.py
Normal 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)
|
||||
|
||||
86
instances/tests/test_live_disk_resize.py
Normal file
86
instances/tests/test_live_disk_resize.py
Normal 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)
|
||||
401
instances/tests/test_live_guest.py
Normal file
401
instances/tests/test_live_guest.py
Normal 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)
|
||||
96
instances/tests/test_live_iso.py
Normal file
96
instances/tests/test_live_iso.py
Normal 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)
|
||||
112
instances/tests/test_live_xml.py
Normal file
112
instances/tests/test_live_xml.py
Normal 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)
|
||||
294
instances/tests/test_live_xml_effects.py
Normal file
294
instances/tests/test_live_xml_effects.py
Normal 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)
|
||||
64
instances/tests/test_migrate_form.py
Normal file
64
instances/tests/test_migrate_form.py
Normal 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])
|
||||
97
instances/tests/test_migration_bookkeeping.py
Normal file
97
instances/tests/test_migration_bookkeeping.py
Normal 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
|
||||
116
instances/tests/test_migration_log.py
Normal file
116
instances/tests/test_migration_log.py
Normal 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)"})
|
||||
95
instances/tests/test_missing_fields.py
Normal file
95
instances/tests/test_missing_fields.py
Normal 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()
|
||||
143
instances/tests/test_moved_while_waiting.py
Normal file
143
instances/tests/test_moved_while_waiting.py
Normal 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))
|
||||
63
instances/tests/test_new_disk_name.py
Normal file
63
instances/tests/test_new_disk_name.py
Normal 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)
|
||||
230
instances/tests/test_page_controls.py
Normal file
230
instances/tests/test_page_controls.py
Normal 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))
|
||||
137
instances/tests/test_pending_edits.py
Normal file
137
instances/tests/test_pending_edits.py
Normal 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)
|
||||
183
instances/tests/test_quota.py
Normal file
183
instances/tests/test_quota.py
Normal 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)
|
||||
62
instances/tests/test_quota_lock.py
Normal file
62
instances/tests/test_quota_lock.py
Normal 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)
|
||||
117
instances/tests/test_root_pass.py
Normal file
117
instances/tests/test_root_pass.py
Normal 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()
|
||||
419
instances/tests/test_security_mutations.py
Normal file
419
instances/tests/test_security_mutations.py
Normal 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()
|
||||
172
instances/tests/test_states.py
Normal file
172
instances/tests/test_states.py
Normal 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
|
||||
194
instances/tests/test_stats_sample.py
Normal file
194
instances/tests/test_stats_sample.py
Normal 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"])
|
||||
76
instances/tests/test_template_flag.py
Normal file
76
instances/tests/test_template_flag.py
Normal 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)
|
||||
68
instances/tests/test_template_quota.py
Normal file
68
instances/tests/test_template_quota.py
Normal 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()
|
||||
64
instances/tests/test_template_rules.py
Normal file
64
instances/tests/test_template_rules.py
Normal 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)
|
||||
27
instances/tests/test_update_console.py
Normal file
27
instances/tests/test_update_console.py
Normal 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")
|
||||
1172
instances/tests/test_views.py
Normal file
1172
instances/tests/test_views.py
Normal file
File diff suppressed because it is too large
Load diff
167
instances/tests/test_xss.py
Normal file
167
instances/tests/test_xss.py
Normal 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")
|
||||
Loading…
Add table
Add a link
Reference in a new issue