You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/engine/tests/test_registration_http.py

1002 lines
48 KiB
Python

"""Production database-mode registration and authorization HTTP boundary."""
from __future__ import annotations
import asyncio
import ipaddress
import json
import sys
import time
import types
from contextlib import closing
from pathlib import Path
import pytest
from fastapi.testclient import TestClient
from starlette.websockets import WebSocketDisconnect
try:
import libvirt # noqa: F401
except ModuleNotFoundError:
stub = types.ModuleType("libvirt")
stub.libvirtError = type("libvirtError", (Exception,), {})
sys.modules["libvirt"] = stub
from tests.test_database_http import MemoryStore # noqa: E402
from virsh_panel import app as app_module # noqa: E402
from virsh_panel.auth import hash_password # noqa: E402
from virsh_panel.config import Settings # noqa: E402
from virsh_panel.database import DatabasePanelState, DatabaseTemplateStore # noqa: E402
from virsh_panel.libvirt_service import VMError # noqa: E402
from virsh_panel.metrics import host_scope # noqa: E402
from virsh_panel.cloud_templates import template_scope # noqa: E402
from virsh_panel.ssh_keys import SSHKeyError, _name, _public_key # noqa: E402
ORIGIN = "https://panel.example.test"
PASSWORD = "correct-horse-battery-staple"
CREATE_VM = {
"name": "tenant-vm", "vcpu": 2, "memory_mib": 2048,
"disk_gib": 20, "network": "bridge:br0", "iso": "AlmaLinux-10.iso",
}
GUEST_PUBLIC_KEY = (
"ssh-ed25519 "
"AAAAC3NzaC1lZDI1NTE5AAAAIF7mFh4aYz3lRzNqjoFQasAQLpm7BdSULhe1iWuvj3y5 "
"panel-test"
)
CLOUD_VM = {
"source": "cloud", "template_id": "alma10-template",
"name": "tenant-cloud", "vcpu": 2, "memory_mib": 2048,
"disk_gib": 20, "network": "bridge:br0", "public_ip_cidr": "8.8.8.18/24",
"gateway": "8.8.8.1", "dns_servers": ["1.1.1.1"],
}
class _MemorySSHKeys:
"""Mimic the owner-scoped SQL boundary for production-mode HTTP tests."""
def __init__(self):
self.rows = {}
self.next_id = 1
def list_for_user(self, user_id):
return [row.copy() for owner, row in self.rows.values() if owner == user_id]
def create_for_user(self, user_id, name, public_key):
name = _name(name)
public_key, fingerprint = _public_key(public_key)
if any(owner == user_id and row["fingerprint"] == fingerprint
for owner, row in self.rows.values()):
raise SSHKeyError("此 SSH 公钥已添加到当前账户", 409)
key_id = self.next_id
self.next_id += 1
row = {"id": key_id, "name": name, "public_key": public_key,
"fingerprint": fingerprint, "created_at": 100}
self.rows[key_id] = (user_id, row)
return row.copy()
def get_for_user(self, user_id, key_id):
found = self.rows.get(key_id)
return found[1].copy() if found is not None and found[0] == user_id else None
def delete_for_user(self, user_id, key_id):
if self.get_for_user(user_id, key_id) is None:
return False
del self.rows[key_id]
return True
class _Manager:
profile = {
"host": "vmhost.example.test", "port": 22,
"fingerprint": "SHA256:configured-host", "key_locked": False,
"region": "东京", "storage_pool": "/home/kvm", "iso_pool": "/home/iso",
"default_network": "bridge:br0", "ssh_target": "vp-managed",
"ssh_config_file": "/fake/config", "ssh_known_hosts_file": "/fake/known_hosts",
}
def current(self):
return self.profile
def close(self):
pass
class _Service:
def __init__(self):
self.vms = {}
self.console_calls = []
self.cloud_specs = []
self.reinstall_specs = []
def create_vm(self, spec):
vm = {
"uuid": spec["vm_uuid"], "name": spec["name"], "state": "running",
"vcpu": spec["vcpu"], "memory_mib": spec["memory_mib"],
"disks": [], "autostart": True,
}
self.vms[vm["uuid"]] = vm
return vm
def create_cloud_vm(self, spec, volume_name):
self.cloud_specs.append((spec.copy(), volume_name))
vm = self.create_vm(spec)
vm.update({
"managed": True,
"os_source": "cloud_template",
"public_ip_cidr": spec["public_ip_cidr"],
"credential_generation": f"panel-seed-{vm['uuid']}.iso",
})
return vm
def reinstall_cloud_vm(self, vm_id, volume_name, *, os_name=None,
ssh_public_key="", root_password_hash=None,
progress=None):
vm = self.get_vm(vm_id)
self.reinstall_specs.append((vm_id, volume_name, ssh_public_key,
root_password_hash, os_name))
if progress is not None:
progress("completed")
generation = f"panel-seed-reinstall-{vm_id}.iso"
vm["credential_generation"] = generation
return {"vm": vm, "credential_generation": generation}
def resources(self):
return {"networks": ["bridge:br0"], "isos": [], "storage_pool": "/home/kvm"}
def list_vms(self):
return list(self.vms.values())
def get_vm(self, vm_id):
if vm_id not in self.vms:
raise VMError("虚拟机不存在", 404)
return self.vms[vm_id]
def action(self, vm_id, _action):
return self.get_vm(vm_id)
def delete_vm(self, vm_id, _delete_disks):
self.get_vm(vm_id)
del self.vms[vm_id]
return {"uuid": vm_id, "deleted": True, "deleted_disks": []}
def delete_firewall_filter(self, _vm_id):
return {"deleted": True, "already_absent": True}
def console_port(self, vm_id):
self.console_calls.append(vm_id)
self.get_vm(vm_id)
return 5907
class _NoMetrics:
def __init__(self, *_args, **_kwargs):
pass
def start(self):
pass
def stop(self):
pass
def close(self):
return True
async def aclose(self):
return True
def _session_client(app):
# Independent cookies share the outer client's single application
# lifespan. Closing a tenant session must not stop the whole application.
return closing(TestClient(app, base_url=ORIGIN))
def _login(client: TestClient, email: str):
response = client.post("/api/v1/login", json={
"email": email, "password": PASSWORD,
})
assert response.status_code == 200
return {"X-CSRF-Token": response.json()["csrf_token"]}
def _register(client: TestClient, address: str, username: str):
code = client.post("/api/v1/register/code", json={"email": address})
assert code.status_code == 200 and code.json() == {"sent": True}
response = client.post("/api/v1/register", json={
"username": username, "email": address,
"password": PASSWORD, "code": "123456",
})
assert response.status_code == 201
assert response.json() == {"registered": True, "approved": False}
def test_template_rename_is_admin_only_and_ordinary_users_can_list(monkeypatch, tmp_path):
store = MemoryStore()
service = _Service()
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), _Manager(),
DatabaseTemplateStore(store), store,
))
monkeypatch.setattr(app_module, "MetricsCollector", _NoMetrics)
settings = Settings(
data_dir=tmp_path / "data",
static_dir=Path(__file__).resolve().parents[1] / "static",
)
app = app_module.create_app(settings, service_factory=lambda _profile: service)
token = (settings.data_dir / "setup-token").read_text(encoding="ascii").strip()
scope = template_scope(_Manager.profile)
template_id = "alma9-12345678-abcdef0123456789"
record = {
"id": template_id, "name": "AlmaLinux 9", "os_family": "AlmaLinux",
"os_version": "9", "sha256": "f" * 64,
"volume_name": "panel-template-alma9-12345678-abcdef0123456789.qcow2",
}
endpoint = f"/api/v1/vm-templates/{template_id}"
with TestClient(app, base_url=ORIGIN) as admin:
assert admin.patch(endpoint, json={"name": "Rename"}).status_code == 401
configured = admin.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "database-password", "setup_token": token,
})
assert configured.status_code == 200
created = admin.post("/api/v1/setup/admin", json={
"token": token, "username": "initial", "password": PASSWORD,
})
assert created.status_code == 200
admin_headers = {"X-CSRF-Token": created.json()["csrf_token"]}
templates = DatabaseTemplateStore(store)
templates.add(scope, record)
templates.add(scope, {**record, "id": "another", "name": "Other template"})
templates.add("b" * 64, {**record, "name": "Different host"})
assert admin.patch(endpoint, json={"name": "Rename"},
headers=admin_headers).status_code == 403
store.users.promote("initial")
store.set("test_user", "tenant", json.dumps({
"id": 2, "username": "tenant", "email": "tenant@example.test",
"password_hash": hash_password(PASSWORD), "admin": False,
"approved": True, "email_verified": True, "created_at": 100,
}))
with _session_client(app) as tenant:
tenant_headers = _login(tenant, "tenant@example.test")
listed = tenant.get("/api/v1/vm-templates")
assert listed.status_code == 200
assert [row["id"] for row in listed.json()["templates"]] == [
template_id, "another",
]
assert tenant.patch(endpoint, json={"name": "Hijack"},
headers=tenant_headers).status_code == 403
assert tenant.post("/api/v1/vm-templates/import", json={
"name": "Extra", "url": "https://invalid.example/image.qcow2",
"sha256": "a" * 64,
}, headers=tenant_headers).status_code == 403
assert admin.patch(endpoint, json={"name": "Rename"}).status_code == 403
assert admin.patch(endpoint, json={"name": "Other TEMPLATE"},
headers=admin_headers).status_code == 409
assert admin.patch(endpoint, json={"name": " "},
headers=admin_headers).status_code == 400
missing = admin.patch("/api/v1/vm-templates/missing", json={"name": "Missing"},
headers=admin_headers)
assert missing.status_code == 404
renamed = admin.patch(endpoint, json={"name": " AlmaLinux 9 Gold "},
headers=admin_headers)
assert renamed.status_code == 200
assert renamed.json()["template"] == {**record, "name": "AlmaLinux 9 Gold"}
assert DatabaseTemplateStore(store).get(scope, template_id) == renamed.json()["template"]
assert templates.get("b" * 64, template_id)["name"] == "Different host"
def test_registration_smtp_approval_and_per_user_vm_isolation(monkeypatch, tmp_path):
store = MemoryStore()
service = _Service()
sent = []
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), _Manager(),
DatabaseTemplateStore(store), store,
))
monkeypatch.setattr(app_module, "MetricsCollector", _NoMetrics)
monkeypatch.setattr(
app_module, "send_verification_code",
lambda config, email, code: sent.append((config.host, email, code)),
)
settings = Settings(
data_dir=tmp_path / "data",
static_dir=Path(__file__).resolve().parents[1] / "static",
)
app = app_module.create_app(settings, service_factory=lambda _profile: service)
token = (settings.data_dir / "setup-token").read_text(encoding="ascii").strip()
with TestClient(app, base_url=ORIGIN) as admin:
configured = admin.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "database-password", "setup_token": token,
})
assert configured.status_code == 200
initial = admin.post("/api/v1/setup/admin", json={
"token": token, "username": "firstuser", "password": PASSWORD,
})
assert initial.status_code == 200
admin_headers = {"X-CSRF-Token": initial.json()["csrf_token"]}
assert admin.get("/api/v1/session").json()["admin"] is False
assert admin.get("/api/v1/smtp/settings").status_code == 403
# The operator promotes the initial account and adds its email in MariaDB.
store.users.promote("firstuser")
assert admin.get("/api/v1/session").json()["admin"] is True
initial_account = store.users.get_by_username("firstuser")
assert initial_account["email"] is None
with _session_client(app) as missing_email:
assert missing_email.post("/api/v1/login", json={
"email": "first@example.test", "password": PASSWORD,
}).status_code == 401
store.set("test_user", "firstuser", json.dumps({
**initial_account, "email": "first@example.test",
}))
with _session_client(app) as fresh_admin:
assert fresh_admin.post("/api/v1/login", json={
"username": "firstuser", "password": PASSWORD,
}).status_code == 422
assert fresh_admin.post("/api/v1/login", json={
"email": "firstuser", "password": PASSWORD,
}).status_code == 401
assert _login(fresh_admin, "FIRST@EXAMPLE.TEST")
assert fresh_admin.get("/api/v1/session").json()["admin"] is True
smtp = admin.put("/api/v1/smtp/settings", json={
"host": "smtp.example.test", "port": 587, "tls_mode": "starttls",
"from_address": "panel@example.test", "username": "mailer",
"password": "smtp-secret-password",
}, headers=admin_headers)
assert smtp.status_code == 200
assert "smtp-secret-password" not in smtp.text
original_sender = app_module.send_verification_code
def fail_delivery(_config, _email, _code):
raise app_module.SMTPError("模拟 SMTP 发送失败", 502)
monkeypatch.setattr(app_module, "send_verification_code", fail_delivery)
with _session_client(app) as visitor:
failed_send = visitor.post("/api/v1/register/code", json={
"email": "delivery-fail@example.test",
})
assert failed_send.status_code == 200
assert failed_send.json() == {"sent": True}
# A failed background delivery must remove the challenge so the
# user is not trapped behind the resend cooldown.
assert store.get("test_code", "delivery-fail@example.test") is None
monkeypatch.setattr(app_module, "send_verification_code", original_sender)
with _session_client(app) as visitor:
retried = visitor.post("/api/v1/register/code", json={
"email": "delivery-fail@example.test",
})
assert retried.status_code == failed_send.status_code
assert retried.json() == failed_send.json()
assert store.get("test_code", "delivery-fail@example.test") == "123456"
sent.clear()
with _session_client(app) as first:
_register(first, "one@example.test", "tenantone")
assert sent == [("smtp.example.test", "one@example.test", "123456")]
first_headers = _login(first, "ONE@EXAMPLE.TEST")
assert first.get("/api/v1/session").json()["approved"] is False
assert first.post("/api/v1/vms", json=CREATE_VM,
headers=first_headers).status_code == 403
for protected in (
"/api/v1/host", "/api/v1/update/settings",
"/api/v1/smtp/settings", "/api/v1/users/pending",
):
assert first.get(protected).status_code == 403
pending = admin.get("/api/v1/users/pending")
assert pending.status_code == 200
items = pending.json()["items"]
assert len(items) == 1 and items[0]["username"] == "tenantone"
assert "password_hash" not in items[0]
approve = admin.post(f"/api/v1/users/{items[0]['id']}/approve",
headers=admin_headers)
assert approve.status_code == 200
assert first.get("/api/v1/session").json()["approved"] is True
own = first.post("/api/v1/vms", json=CREATE_VM, headers=first_headers)
assert own.status_code == 201
own_id = own.json()["uuid"]
with _session_client(app) as second:
_register(second, "two@example.test", "tenanttwo")
second_headers = _login(second, "two@example.test")
second_id = store.users.get_by_username("tenanttwo")["id"]
assert admin.post(f"/api/v1/users/{second_id}/approve",
headers=admin_headers).status_code == 200
other = second.post("/api/v1/vms", json={**CREATE_VM, "name": "other-vm"},
headers=second_headers)
assert other.status_code == 201
other_id = other.json()["uuid"]
assert [vm["uuid"] for vm in first.get("/api/v1/vms").json()["items"]] == [own_id]
assert [vm["uuid"] for vm in second.get("/api/v1/vms").json()["items"]] == [other_id]
assert len(admin.get("/api/v1/vms").json()["items"]) == 2
assert first.get(f"/api/v1/vms/{other_id}").status_code == 404
assert first.post(f"/api/v1/vms/{other_id}/credential",
headers=first_headers).status_code == 404
assert first.get(f"/api/v1/vms/{other_id}/metrics").status_code == 404
assert first.post(f"/api/v1/vms/{other_id}/actions", json={
"action": "reboot",
}, headers=first_headers).status_code == 404
assert first.delete(f"/api/v1/vms/{other_id}",
headers=first_headers).status_code == 404
assert first.get(f"/api/v1/vms/{own_id}").status_code == 200
assert first.get("/api/v1/host").status_code == 403
assert first.put("/api/v1/update/settings", json={
"repository_url": "https://g.luoli.live/root/virt.git", "branch": "main",
"access_token": "forbidden",
}, headers=first_headers).status_code == 403
assert first.put("/api/v1/smtp/settings", json={
"host": "evil.example.test", "port": 587, "tls_mode": "starttls",
"from_address": "evil@example.test",
}, headers=first_headers).status_code == 403
assert first.post(f"/api/v1/users/{second_id}/approve",
headers=first_headers).status_code == 403
cookie = first.cookies.get("virsh_panel_session")
with pytest.raises(WebSocketDisconnect) as denied:
with first.websocket_connect(
f"wss://panel.example.test/api/v1/vms/{other_id}/console",
headers={
"host": "panel.example.test", "origin": ORIGIN,
"cookie": f"virsh_panel_session={cookie}",
},
):
pass
assert denied.value.code == 4404
assert service.console_calls == []
monkeypatch.setattr(app_module, "CONSOLE_ACCESS_CHECK_SECONDS", 0.05)
async def held_console(_websocket, **_kwargs):
# If the watchdog fails to close promptly, the relay
# closes with 1011 after a bounded fallback delay.
await asyncio.sleep(1)
raise app_module.ConsoleRelayError("test relay timeout")
monkeypatch.setattr(app_module, "relay_console", held_console)
own_console = f"wss://panel.example.test/api/v1/vms/{own_id}/console"
own_cookie = first.cookies.get("virsh_panel_session")
with first.websocket_connect(own_console, headers={
"host": "panel.example.test", "origin": ORIGIN,
"cookie": f"virsh_panel_session={own_cookie}",
}) as console:
assert first.post("/api/v1/logout", headers=first_headers).status_code == 200
with pytest.raises(WebSocketDisconnect) as revoked:
console.receive_text()
assert revoked.value.code == 4403
first_headers = _login(first, "one@example.test")
own_cookie = first.cookies.get("virsh_panel_session")
with first.websocket_connect(own_console, headers={
"host": "panel.example.test", "origin": ORIGIN,
"cookie": f"virsh_panel_session={own_cookie}",
}) as console:
store.users.delete_vm_owner(host_scope(_Manager.profile), own_id)
with pytest.raises(WebSocketDisconnect) as ownership_revoked:
console.receive_text()
assert ownership_revoked.value.code == 4403
# A deleted username may later be reused. Its old bearer
# cookie must not acquire the replacement account's role.
old_account = store.users.get_by_username("tenantone")
store.delete("test_user", "tenantone")
replacement = {**old_account, "id": old_account["id"] + 1000,
"admin": True}
store.set("test_user", "tenantone", json.dumps(replacement))
assert first.get("/api/v1/session").json()["authenticated"] is False
assert first.get("/api/v1/smtp/settings").status_code == 401
assert first.post("/api/v1/vms", json=CREATE_VM,
headers=first_headers).status_code == 401
def test_per_user_ssh_key_library_and_cloud_vm_selection(monkeypatch, tmp_path):
store = MemoryStore()
key_store = _MemorySSHKeys()
service = _Service()
def components(directory, *_args):
state = DatabasePanelState(directory, store, store.users)
state.ssh_keys = key_store
return state, _Manager(), DatabaseTemplateStore(store), store
monkeypatch.setattr(app_module, "make_components", components)
monkeypatch.setattr(app_module, "MetricsCollector", _NoMetrics)
settings = Settings(
data_dir=tmp_path / "data",
static_dir=Path(__file__).resolve().parents[1] / "static",
)
app = app_module.create_app(settings, service_factory=lambda _profile: service)
token = (settings.data_dir / "setup-token").read_text(encoding="ascii").strip()
with TestClient(app, base_url=ORIGIN) as admin:
assert admin.get("/api/v1/ssh-keys").status_code == 401
assert admin.post("/api/v1/ssh-keys", json={
"name": "initial", "public_key": GUEST_PUBLIC_KEY,
}).status_code == 401
assert admin.delete("/api/v1/ssh-keys/1").status_code == 401
assert admin.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "database-password", "setup_token": token,
}).status_code == 200
initial = admin.post("/api/v1/setup/admin", json={
"token": token, "username": "firstuser", "password": PASSWORD,
})
assert initial.status_code == 200
admin_headers = {"X-CSRF-Token": initial.json()["csrf_token"]}
store.users.promote("firstuser")
DatabaseTemplateStore(store).add(template_scope(_Manager.profile), {
"id": "alma10-template", "name": "AlmaLinux 10",
"volume_name": "panel-template-alma10.qcow2",
})
# Even an administrator has a personal key library, not every
# tenant's keys. No private-key content is accepted by the API.
assert admin.get("/api/v1/ssh-keys").json() == {"items": []}
rejected_private = admin.post("/api/v1/ssh-keys", json={
"name": "wrong", "public_key": "-----BEGIN OPENSSH PRIVATE KEY-----\nsecret",
}, headers=admin_headers)
assert rejected_private.status_code in (400, 422)
store.users.issue_registration_code("one@example.test", "123456")
first_account = store.users.register_with_code(
"tenantone", "one@example.test", PASSWORD, "123456",
)
store.users.issue_registration_code("two@example.test", "123456")
second_account = store.users.register_with_code(
"tenanttwo", "two@example.test", PASSWORD, "123456",
)
with _session_client(app) as first, _session_client(app) as second:
first_headers = _login(first, "one@example.test")
second_headers = _login(second, "two@example.test")
assert first.get("/api/v1/session").json()["approved"] is False
assert first.get("/api/v1/ssh-keys").json() == {"items": []}
assert first.post("/api/v1/ssh-keys", json={
"name": "laptop", "public_key": GUEST_PUBLIC_KEY,
}).status_code == 403
imported = first.post("/api/v1/ssh-keys", json={
"name": "laptop", "public_key": GUEST_PUBLIC_KEY,
}, headers=first_headers)
assert imported.status_code == 201
first_key = imported.json()
assert first_key["name"] == "laptop"
assert first_key["public_key"].startswith("ssh-ed25519 ")
assert first_key["fingerprint"].startswith("SHA256:")
assert isinstance(first_key["id"], int)
assert first.post("/api/v1/ssh-keys", json={
"name": "duplicate comment", "public_key": GUEST_PUBLIC_KEY,
}, headers=first_headers).status_code == 409
assert first.get("/api/v1/ssh-keys").json()["items"] == [first_key]
assert second.get("/api/v1/ssh-keys").json() == {"items": []}
assert admin.get("/api/v1/ssh-keys").json() == {"items": []}
assert first.post("/api/v1/vms", json={
**CLOUD_VM, "guest_ssh_key_id": first_key["id"],
}, headers=first_headers).status_code == 403
# The same public key is allowed in another account, but its
# record has a different ID and remains independently owned.
second_import = second.post("/api/v1/ssh-keys", json={
"name": "other laptop", "public_key": GUEST_PUBLIC_KEY,
}, headers=second_headers)
assert second_import.status_code == 201
second_key = second_import.json()
assert second_key["id"] != first_key["id"]
assert second.get("/api/v1/ssh-keys").json()["items"] == [second_key]
assert second.delete(f"/api/v1/ssh-keys/{first_key['id']}",
headers=second_headers).status_code == 404
assert first.delete("/api/v1/ssh-keys/-1",
headers=first_headers).status_code == 404
assert admin.delete(f"/api/v1/ssh-keys/{first_key['id']}",
headers=admin_headers).status_code == 404
assert first.get("/api/v1/ssh-keys").json()["items"] == [first_key]
assert admin.post(f"/api/v1/users/{first_account['id']}/approve",
headers=admin_headers).status_code == 200
assert admin.post(f"/api/v1/users/{second_account['id']}/approve",
headers=admin_headers).status_code == 200
before = len(service.cloud_specs)
for client, headers, forbidden_id in (
(first, first_headers, second_key["id"]),
(second, second_headers, first_key["id"]),
(admin, admin_headers, first_key["id"]),
):
forbidden = client.post("/api/v1/vms", json={
**CLOUD_VM, "guest_ssh_key_id": forbidden_id,
}, headers=headers)
assert forbidden.status_code == 404
missing = first.post("/api/v1/vms", json={
**CLOUD_VM, "guest_ssh_key_id": 999999,
}, headers=first_headers)
assert missing.status_code == 404
for conflicting in (
{"guest_ssh_key_id": first_key["id"],
"guest_ssh_public_key": GUEST_PUBLIC_KEY},
):
response = first.post("/api/v1/vms", json={
**CLOUD_VM, **conflicting,
}, headers=first_headers)
assert response.status_code == 422
assert len(service.cloud_specs) == before
selected = first.post("/api/v1/vms", json={
**CLOUD_VM, "guest_ssh_key_id": first_key["id"],
"root_password": "A-strong-guest-password-2026",
}, headers=first_headers)
assert selected.status_code == 201
spec, _volume = service.cloud_specs[-1]
assert spec["guest_ssh_public_key"] == first_key["public_key"]
assert "guest_ssh_key_id" not in spec
assert spec["root_password_hash"].startswith("$6$")
assert selected.json()["auth_mode"] == "ssh_key_password"
assert selected.json()["password_available"]
assert first.post(
f"/api/v1/vms/{selected.json()['uuid']}/credential",
headers=first_headers,
).json()["password"] == "A-strong-guest-password-2026"
assert second.get(f"/api/v1/vms/{selected.json()['uuid']}").status_code == 404
key_with_generated_password = first.post("/api/v1/vms", json={
**CLOUD_VM, "name": "saved-key-auto-password",
"public_ip_cidr": "8.8.8.21/24",
"guest_ssh_key_id": first_key["id"],
"root_password": "",
}, headers=first_headers)
assert key_with_generated_password.status_code == 201
key_spec, _key_volume = service.cloud_specs[-1]
assert key_spec["guest_ssh_public_key"] == first_key["public_key"]
assert key_spec["root_password_hash"].startswith("$6$")
assert key_with_generated_password.json()["auth_mode"] == "ssh_key_password"
assert key_with_generated_password.json()["password_available"]
key_credential = first.post(
f"/api/v1/vms/{key_with_generated_password.json()['uuid']}/credential",
headers=first_headers,
).json()
assert key_credential["auth_mode"] == "ssh_key_password"
assert len(key_credential["password"]) == 32
assert any(c.isupper() for c in key_credential["password"])
assert any(c.islower() for c in key_credential["password"])
assert any(c.isdigit() for c in key_credential["password"])
assert any(not c.isalnum() and not c.isspace()
for c in key_credential["password"])
assert set(key_credential["password"]) <= set(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789!@#$%*-_=+?"
)
from passlib.hash import sha512_crypt
assert sha512_crypt.verify(
key_credential["password"], key_spec["root_password_hash"],
)
assert key_credential["password"] not in key_with_generated_password.text
assert key_credential["password"] not in repr(service.cloud_specs)
assert second.get(
f"/api/v1/vms/{key_with_generated_password.json()['uuid']}"
).status_code == 404
reinstall_url = f"/api/v1/vms/{selected.json()['uuid']}/reinstall"
reinstall_body = {"template_id": "alma10-template",
"confirmation_name": "tenant-cloud"}
for client, headers, key_id in (
(first, first_headers, second_key["id"]),
(admin, admin_headers, first_key["id"]),
):
assert client.post(reinstall_url, json={
**reinstall_body, "ssh_key_id": key_id,
}, headers=headers).status_code == 404
assert second.post(reinstall_url, json={
**reinstall_body, "ssh_key_id": second_key["id"],
}, headers=second_headers).status_code == 404
assert first.post(reinstall_url, json={
**reinstall_body, "ssh_key_id": first_key["id"],
"ssh_public_key": GUEST_PUBLIC_KEY,
}, headers=first_headers).status_code == 422
assert service.reinstall_specs == []
queued = first.post(reinstall_url, json={
**reinstall_body, "ssh_key_id": first_key["id"],
"root_password": "A-strong-guest-password-2026",
}, headers=first_headers)
assert queued.status_code == 202
for _ in range(100):
job = first.get(f"/api/v1/reinstall-jobs/{queued.json()['job_id']}",
headers=first_headers)
assert job.status_code == 200
if job.json()["status"] != "queued" and job.json()["status"] != "running":
break
time.sleep(0.01)
assert job.json()["status"] == "succeeded"
assert service.reinstall_specs[-1][2] == first_key["public_key"]
assert service.reinstall_specs[-1][3].startswith("$6$")
assert "generated_password" not in job.json()
assert first.post(
f"/api/v1/vms/{selected.json()['uuid']}/credential",
headers=first_headers,
).json()["password"] == "A-strong-guest-password-2026"
# Existing create paths continue to accept a one-off pasted key
# or an initial root password without a saved-key ID.
manual = first.post("/api/v1/vms", json={
**CLOUD_VM, "name": "manual-key-vm",
"public_ip_cidr": "8.8.8.19/24",
"guest_ssh_public_key": GUEST_PUBLIC_KEY,
}, headers=first_headers)
assert manual.status_code == 201
assert service.cloud_specs[-1][0]["guest_ssh_public_key"] == GUEST_PUBLIC_KEY
manual_claim = f"{host_scope(_Manager.profile)}.8.8.8.19"
assert store.get("ip_claim", manual_claim) is not None
duplicate_manual = first.post("/api/v1/vms", json={
**CLOUD_VM, "name": "duplicate-manual-ip",
"public_ip_cidr": "8.8.8.19/24",
"guest_ssh_public_key": GUEST_PUBLIC_KEY,
}, headers=first_headers)
assert duplicate_manual.status_code == 409
assert first.delete(f"/api/v1/vms/{manual.json()['uuid']}",
headers=first_headers).status_code == 200
assert store.get("ip_claim", manual_claim) is None
password = first.post("/api/v1/vms", json={
**CLOUD_VM, "name": "password-vm",
"public_ip_cidr": "8.8.8.20/24",
"root_password": "A-strong-guest-password-2026",
}, headers=first_headers)
assert password.status_code == 201
assert password.json()["auth_mode"] == "password"
assert first.delete(f"/api/v1/ssh-keys/{first_key['id']}").status_code == 403
deleted = first.delete(f"/api/v1/ssh-keys/{first_key['id']}",
headers=first_headers)
assert 200 <= deleted.status_code < 300
assert first.get("/api/v1/ssh-keys").json() == {"items": []}
assert second.get("/api/v1/ssh-keys").json()["items"] == [second_key]
assert first.post("/api/v1/vms", json={
**CLOUD_VM, "name": "deleted-key-vm",
"guest_ssh_key_id": first_key["id"],
}, headers=first_headers).status_code == 404
assert first.post(reinstall_url, json={
**reinstall_body, "ssh_key_id": first_key["id"],
}, headers=first_headers).status_code == 404
assert first.get(f"/api/v1/vms/{selected.json()['uuid']}").status_code == 200
def test_host_public_pool_allocates_globally_and_preserves_tenant_isolation(
monkeypatch, tmp_path,
):
store = MemoryStore()
service = _Service()
manager = _Manager()
manager.profile = {
**_Manager.profile,
"host": "8.8.8.3",
"public_pool_cidr": "8.8.8.0/24",
"public_gateway": "8.8.8.1",
"public_dns_servers": ["1.1.1.1", "8.8.4.4"],
"public_reserved_ips": ["8.8.8.2", "8.8.8.5"],
}
# An existing, panel-visible libvirt guest already occupies one address.
service.vms["00000000-0000-4000-8000-000000000004"] = {
"uuid": "00000000-0000-4000-8000-000000000004",
"name": "existing-vm", "state": "running", "vcpu": 1,
"memory_mib": 1024, "disks": [], "autostart": True,
"public_ip_cidr": "8.8.8.4/24",
}
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), manager,
DatabaseTemplateStore(store), store,
))
monkeypatch.setattr(app_module, "MetricsCollector", _NoMetrics)
settings = Settings(
data_dir=tmp_path / "data",
static_dir=Path(__file__).resolve().parents[1] / "static",
)
app = app_module.create_app(settings, service_factory=lambda _profile: service)
token = (settings.data_dir / "setup-token").read_text(encoding="ascii").strip()
automatic_body = {
key: value for key, value in CLOUD_VM.items()
if key not in {"public_ip_cidr", "gateway", "dns_servers"}
}
automatic_body["guest_ssh_public_key"] = GUEST_PUBLIC_KEY
network = ipaddress.ip_network(manager.profile["public_pool_cidr"])
excluded = {"8.8.8.0", "8.8.8.1", "8.8.8.2", "8.8.8.3",
"8.8.8.4", "8.8.8.5", "8.8.8.6", "8.8.8.255"}
with TestClient(app, base_url=ORIGIN) as admin:
assert admin.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "database-password", "setup_token": token,
}).status_code == 200
initial = admin.post("/api/v1/setup/admin", json={
"token": token, "username": "operator", "password": PASSWORD,
})
assert initial.status_code == 200
admin_headers = {"X-CSRF-Token": initial.json()["csrf_token"]}
store.users.promote("operator")
DatabaseTemplateStore(store).add(template_scope(manager.profile), {
"id": "alma10-template", "name": "AlmaLinux 10",
"volume_name": "panel-template-alma10.qcow2",
})
# A claim from another panel worker remains occupied even when its VM
# is not yet visible through libvirt's list API.
pool_scope = host_scope(manager.profile)
assert store.insert("ip_claim", f"{pool_scope}.8.8.8.6", json.dumps({
"vm_uuid": "00000000-0000-4000-8000-000000000006",
}))
for username in ("tenantone", "tenanttwo"):
email = f"{username}@example.test"
store.users.issue_registration_code(email, "123456")
account = store.users.register_with_code(username, email, PASSWORD, "123456")
assert admin.post(f"/api/v1/users/{account['id']}/approve",
headers=admin_headers).status_code == 200
with _session_client(app) as first, _session_client(app) as second:
first_headers = _login(first, "tenantone@example.test")
second_headers = _login(second, "tenanttwo@example.test")
resources = first.get("/api/v1/resources")
assert resources.status_code == 200
assert resources.json()["public_pool_enabled"] is True
assert resources.json()["public_pool_cidr"] == "8.8.8.0/24"
assert first.get("/api/v1/host").status_code == 403
# Explicit client-side networking cannot bypass the host pool.
for field, value in (
("public_ip_cidr", "8.8.8.99/24"),
("gateway", "8.8.8.1"),
("dns_servers", ["1.1.1.1"]),
):
rejected = first.post("/api/v1/vms", json={
**automatic_body, field: value,
}, headers=first_headers)
assert rejected.status_code == 422
assert service.cloud_specs == []
first_created = first.post("/api/v1/vms", json=automatic_body,
headers=first_headers)
second_created = second.post("/api/v1/vms", json={
**automatic_body, "name": "tenant-two-cloud",
}, headers=second_headers)
assert first_created.status_code == second_created.status_code == 201
first_ip = service.cloud_specs[0][0]["public_ip_cidr"]
second_ip = service.cloud_specs[1][0]["public_ip_cidr"]
for ip_cidr in (first_ip, second_ip):
interface = ipaddress.ip_interface(ip_cidr)
assert interface.network == network
assert str(interface.ip) not in excluded
assert first_ip != second_ip
for spec, _volume in service.cloud_specs:
assert spec["gateway"] == "8.8.8.1"
assert spec["dns_servers"] == ["1.1.1.1", "8.8.4.4"]
first_id = first_created.json()["uuid"]
second_id = second_created.json()["uuid"]
assert first.get(f"/api/v1/vms/{second_id}").status_code == 404
assert second.get(f"/api/v1/vms/{first_id}").status_code == 404
# Every usable address is occupied in libvirt metadata: no IP may
# be reused even after the allocator has exhausted the /24 pool.
for address in network.hosts():
ip = str(address)
if ip not in excluded and ip not in {first_ip.split("/")[0],
second_ip.split("/")[0]}:
service.vms[f"used-{ip}"] = {"uuid": f"used-{ip}",
"public_ip_cidr": f"{ip}/24"}
exhausted = first.post("/api/v1/vms", json={
**automatic_body, "name": "no-ip-left",
}, headers=first_headers)
assert exhausted.status_code == 409
assert len(service.cloud_specs) == 2
first_claim = f"{pool_scope}.{first_ip.split('/')[0]}"
assert store.get("ip_claim", first_claim) is not None
deleted = first.delete(f"/api/v1/vms/{first_id}", headers=first_headers)
assert deleted.status_code == 200
assert store.get("ip_claim", first_claim) is None
replacement = first.post("/api/v1/vms", json={
**automatic_body, "name": "freed-ip-reused",
}, headers=first_headers)
assert replacement.status_code == 201
assert service.cloud_specs[-1][0]["public_ip_cidr"] == first_ip
# With exactly one free address, a clearly rolled-back libvirt
# failure must release the temporary claim for the next attempt.
del service.vms["used-8.8.8.250"]
free_claim = f"{pool_scope}.8.8.8.250"
original_create = service.create_cloud_vm
def rolled_back(_spec, _volume):
raise VMError("模拟创建失败,回滚已完成", 502)
monkeypatch.setattr(service, "create_cloud_vm", rolled_back)
failed = first.post("/api/v1/vms", json={
**automatic_body, "name": "rolled-back-vm",
}, headers=first_headers)
assert failed.status_code == 502
assert store.get("ip_claim", free_claim) is None
# If libvirt reports incomplete rollback, conservatively retain
# the address claim even though this fake exposes no resulting VM.
def incomplete_rollback(_spec, _volume):
raise VMError("模拟回滚不完整,请人工检查", 502)
monkeypatch.setattr(service, "create_cloud_vm", incomplete_rollback)
uncertain = first.post("/api/v1/vms", json={
**automatic_body, "name": "uncertain-vm",
}, headers=first_headers)
assert uncertain.status_code == 502
assert store.get("ip_claim", free_claim) is not None
monkeypatch.setattr(service, "create_cloud_vm", original_create)
still_exhausted = first.post("/api/v1/vms", json={
**automatic_body, "name": "uncertain-ip-protected",
}, headers=first_headers)
assert still_exhausted.status_code == 409
@pytest.mark.parametrize(("vm_prefix", "first_ip"), [
(None, "123.123.123.114/28"),
(24, "123.123.123.114/24"),
])
def test_provider_28_pool_allocates_only_inside_assigned_block(
monkeypatch, tmp_path, vm_prefix, first_ip,
):
store = MemoryStore()
service = _Service()
manager = _Manager()
manager.profile = {
**_Manager.profile,
"host": "123.123.123.113",
"public_pool_cidr": "123.123.123.112/28",
"public_gateway": "123.123.123.113",
"public_dns_servers": ["1.1.1.1"],
"public_reserved_ips": ["123.123.123.115"],
"public_vm_prefix": vm_prefix,
}
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
DatabasePanelState(directory, store, store.users), manager,
DatabaseTemplateStore(store), store,
))
monkeypatch.setattr(app_module, "MetricsCollector", _NoMetrics)
settings = Settings(
data_dir=tmp_path / "data",
static_dir=Path(__file__).resolve().parents[1] / "static",
)
app = app_module.create_app(settings, service_factory=lambda _profile: service)
token = (settings.data_dir / "setup-token").read_text(encoding="ascii").strip()
automatic_body = {
key: value for key, value in CLOUD_VM.items()
if key not in {"public_ip_cidr", "gateway", "dns_servers"}
}
automatic_body["guest_ssh_public_key"] = GUEST_PUBLIC_KEY
with TestClient(app, base_url=ORIGIN) as admin:
assert admin.post("/api/v1/database/setup", json={
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
"username": "panel", "password": "database-password", "setup_token": token,
}).status_code == 200
initial = admin.post("/api/v1/setup/admin", json={
"token": token, "username": "operator", "password": PASSWORD,
})
assert initial.status_code == 200
headers = {"X-CSRF-Token": initial.json()["csrf_token"]}
store.users.promote("operator")
DatabaseTemplateStore(store).add(template_scope(manager.profile), {
"id": "alma10-template", "name": "AlmaLinux 10",
"volume_name": "panel-template-alma10.qcow2",
})
created = admin.post("/api/v1/vms", json=automatic_body, headers=headers)
assert created.status_code == 201
assert service.cloud_specs[0][0]["public_ip_cidr"] == first_ip
assert service.cloud_specs[0][0]["gateway"] == "123.123.123.113"
# Exhaust the small provider allocation; never spill into the /24.
for address in ipaddress.ip_network("123.123.123.112/28").hosts():
ip = str(address)
if ip not in {"123.123.123.113", "123.123.123.114", "123.123.123.115"}:
service.vms[f"used-{ip}"] = {"uuid": f"used-{ip}",
"public_ip_cidr": f"{ip}/{vm_prefix or 28}"}
exhausted = admin.post("/api/v1/vms", json={
**automatic_body, "name": "no-provider-ip-left",
}, headers=headers)
assert exhausted.status_code == 409
assert len(service.cloud_specs) == 1