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.
449 lines
18 KiB
Python
449 lines
18 KiB
Python
"""First-run database and update routes with isolated in-memory dependencies."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import stat
|
|
import sys
|
|
import threading
|
|
import types
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
from fastapi.testclient import TestClient
|
|
|
|
# The HTTP boundary is tested with fake VM services; native libvirt is not
|
|
# available on ordinary development machines.
|
|
try:
|
|
import libvirt # noqa: F401
|
|
except ModuleNotFoundError:
|
|
stub = types.ModuleType("libvirt")
|
|
stub.libvirtError = type("libvirtError", (Exception,), {})
|
|
sys.modules["libvirt"] = stub
|
|
|
|
from virsh_panel import app as app_module
|
|
from virsh_panel.auth import hash_password
|
|
from virsh_panel.config import Settings
|
|
from virsh_panel.database import DatabasePanelState, DatabaseTemplateStore
|
|
from virsh_panel.users import UserError, normalize_email
|
|
|
|
|
|
class MemoryUsers:
|
|
"""Only the SQL user-store boundary is replaced in isolated HTTP tests."""
|
|
|
|
def __init__(self, store):
|
|
self.store = store
|
|
|
|
def has_users(self):
|
|
return any(kind == "test_user" for kind, _key in self.store.records)
|
|
|
|
def get_by_username(self, username):
|
|
raw = self.store.get("test_user", username)
|
|
return json.loads(raw) if raw else None
|
|
|
|
def get_by_email(self, email):
|
|
try:
|
|
email = normalize_email(email)
|
|
except UserError:
|
|
return None
|
|
for (kind, _key), raw in self.store.records.items():
|
|
if kind == "test_user":
|
|
account = json.loads(raw)
|
|
if account["email"] == email:
|
|
return account
|
|
return None
|
|
|
|
def get_by_id(self, user_id):
|
|
for (kind, _key), raw in self.store.records.items():
|
|
if kind == "test_user":
|
|
user = json.loads(raw)
|
|
if user["id"] == user_id:
|
|
return user
|
|
return None
|
|
|
|
def create_initial_user(self, username, password, email=None):
|
|
email = normalize_email(email) if email is not None else None
|
|
account = {
|
|
"id": 1, "username": username, "email": email,
|
|
"password_hash": hash_password(password), "admin": False,
|
|
"approved": True, "email_verified": True, "created_at": 100,
|
|
}
|
|
self.store.set("test_user", username, json.dumps(account))
|
|
return account
|
|
|
|
def promote(self, username):
|
|
account = self.get_by_username(username)
|
|
account["admin"] = True
|
|
self.store.set("test_user", username, json.dumps(account))
|
|
|
|
def owns_vm(self, host_scope, vm_id, user_id):
|
|
return self.store.get("test_vm_owner", f"{host_scope}:{vm_id}") == str(user_id)
|
|
|
|
def owner_of_vm(self, host_scope, vm_id):
|
|
value = self.store.get("test_vm_owner", f"{host_scope}:{vm_id}")
|
|
return None if value is None else int(value)
|
|
|
|
def assign_vm(self, host_scope, vm_id, user_id):
|
|
self.store.set("test_vm_owner", f"{host_scope}:{vm_id}", str(user_id))
|
|
|
|
def delete_vm_owner(self, host_scope, vm_id):
|
|
self.store.delete("test_vm_owner", f"{host_scope}:{vm_id}")
|
|
|
|
def list_owned_vm_ids(self, host_scope, user_id):
|
|
prefix = f"{host_scope}:"
|
|
return {key[len(prefix):] for key, owner in self.store.list("test_vm_owner").items()
|
|
if key.startswith(prefix) and owner == str(user_id)}
|
|
|
|
def list_pending_users(self):
|
|
pending = []
|
|
for (kind, _key), raw in self.store.records.items():
|
|
if kind == "test_user":
|
|
account = json.loads(raw)
|
|
if not account["approved"]:
|
|
pending.append({key: value for key, value in account.items()
|
|
if key != "password_hash"})
|
|
return pending
|
|
|
|
def approve_user(self, user_id):
|
|
account = self.get_by_id(user_id)
|
|
if account is None:
|
|
return None
|
|
account["approved"] = True
|
|
self.store.set("test_user", account["username"], json.dumps(account))
|
|
return account
|
|
|
|
@staticmethod
|
|
def generate_code():
|
|
return "123456"
|
|
|
|
def issue_registration_code(self, email, code):
|
|
if any(json.loads(raw)["email"] == email for (kind, _key), raw in self.store.records.items()
|
|
if kind == "test_user"):
|
|
return False
|
|
self.store.set("test_code", email, code)
|
|
return True
|
|
|
|
def revoke_registration_code(self, email, code):
|
|
if self.store.get("test_code", email) != code:
|
|
return False
|
|
self.store.delete("test_code", email)
|
|
return True
|
|
|
|
def register_with_code(self, username, email, password, code):
|
|
if self.store.get("test_code", email) != code:
|
|
raise UserError("验证码无效或已过期")
|
|
email = normalize_email(email)
|
|
if self.get_by_username(username) is not None or self.get_by_email(email) is not None:
|
|
raise UserError("用户名或邮箱已存在", 409)
|
|
account = {
|
|
"id": 1 + sum(kind == "test_user" for kind, _key in self.store.records),
|
|
"username": username, "email": email,
|
|
"password_hash": hash_password(password), "admin": False,
|
|
"approved": False, "email_verified": True, "created_at": 101,
|
|
}
|
|
self.store.set("test_user", username, json.dumps(account))
|
|
self.store.delete("test_code", email)
|
|
return account
|
|
|
|
|
|
class MemoryStore:
|
|
def __init__(self) -> None:
|
|
self.records = {}
|
|
self.users = MemoryUsers(self)
|
|
|
|
def get(self, kind, key):
|
|
return self.records.get((kind, key))
|
|
|
|
def set(self, kind, key, value):
|
|
self.records[(kind, key)] = value
|
|
|
|
def insert(self, kind, key, value):
|
|
if (kind, key) in self.records:
|
|
return False
|
|
self.set(kind, key, value)
|
|
return True
|
|
|
|
def delete(self, kind, key):
|
|
self.records.pop((kind, key), None)
|
|
|
|
def list(self, kind):
|
|
return {key: value for (record_type, key), value in self.records.items()
|
|
if record_type == kind}
|
|
|
|
def get_secret(self, key):
|
|
return self.get("secret", key)
|
|
|
|
def set_secret(self, key, value):
|
|
self.set("secret", key, value)
|
|
|
|
def get_value(self, key):
|
|
return self.get("value", key)
|
|
|
|
def set_value(self, key, value):
|
|
self.set("value", key, value)
|
|
|
|
|
|
class FakeManager:
|
|
def current(self):
|
|
return None
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
|
|
def test_first_run_requires_database_then_admin_and_ignores_old_json(monkeypatch, tmp_path):
|
|
data_dir = tmp_path / "data"
|
|
data_dir.mkdir(mode=0o700)
|
|
(data_dir / "state.json").write_text(
|
|
'{"version":1,"admin":{"username":"old","password_hash":"old"}}',
|
|
encoding="utf-8",
|
|
)
|
|
store = MemoryStore()
|
|
calls = []
|
|
|
|
def make_components(directory, config, key, _ssh_binary):
|
|
calls.append((config, key))
|
|
return (DatabasePanelState(directory, store, store.users), FakeManager(),
|
|
DatabaseTemplateStore(store), store)
|
|
|
|
monkeypatch.setattr(app_module, "make_components", make_components)
|
|
settings = Settings(data_dir=data_dir,
|
|
static_dir=Path(__file__).resolve().parents[1] / "static")
|
|
app = app_module.create_app(settings)
|
|
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
|
|
config = {
|
|
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
|
|
"username": "panel", "password": "test-database-password",
|
|
}
|
|
with TestClient(app, base_url="https://panel.example.test") as client:
|
|
assert client.get("/api/v1/database/status").json() == {
|
|
"configured": False, "setup_required": True,
|
|
}
|
|
assert client.get("/api/v1/setup/status").status_code == 409
|
|
assert client.post("/api/v1/database/setup", json={
|
|
**config, "setup_token": "invalid",
|
|
}).status_code == 403
|
|
assert calls == []
|
|
response = client.post("/api/v1/database/setup", json={
|
|
**config, "setup_token": token,
|
|
})
|
|
assert response.status_code == 200
|
|
assert response.json() == {"configured": True}
|
|
assert calls[0][0] == config and len(calls[0][1]) == 32
|
|
assert client.get("/api/v1/setup/status").json() == {"setup_required": True}
|
|
created = client.post("/api/v1/setup/admin", json={
|
|
"token": token, "username": "admin",
|
|
"password": "correct-horse-battery-staple",
|
|
})
|
|
assert created.status_code == 200
|
|
assert client.get("/api/v1/setup/status").json() == {"setup_required": False}
|
|
session_cookie = client.cookies.get("virsh_panel_session")
|
|
assert ("test_user", "admin") in store.records
|
|
assert store.users.get_by_username("admin")["admin"] is False
|
|
assert store.users.get_by_username("admin")["email"] is None
|
|
assert store.users.get_by_email("admin@example.test") is None
|
|
assert not (data_dir / "setup-token").exists()
|
|
encrypted = (data_dir / "database-config.json").read_bytes()
|
|
assert b"test-database-password" not in encrypted
|
|
assert stat.S_IMODE((data_dir / "master.key").stat().st_mode) == 0o600
|
|
store.set("import_job", "interrupted-job", json.dumps({
|
|
"status": "running", "scope": "previous-host",
|
|
}))
|
|
restarted = app_module.create_app(settings)
|
|
assert json.loads(store.get("import_job", "interrupted-job"))["status"] == "failed"
|
|
with TestClient(restarted, base_url="https://panel.example.test") as client:
|
|
client.cookies.set("virsh_panel_session", session_cookie)
|
|
assert client.get("/api/v1/session").json()["authenticated"] is True
|
|
|
|
|
|
def test_update_routes_require_auth_and_never_return_token(monkeypatch, tmp_path):
|
|
data_dir = tmp_path / "data"
|
|
store = MemoryStore()
|
|
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
|
|
DatabasePanelState(directory, store, store.users), FakeManager(),
|
|
DatabaseTemplateStore(store), store,
|
|
))
|
|
settings = Settings(data_dir=data_dir,
|
|
static_dir=Path(__file__).resolve().parents[1] / "static")
|
|
app = app_module.create_app(settings)
|
|
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
|
|
|
|
class FakeUpdater:
|
|
def __init__(self, *_args):
|
|
self.token = None
|
|
self.job = None
|
|
|
|
def settings(self):
|
|
return {
|
|
"repository": "https://g.luoli.live/root/virt.git", "branch": "main",
|
|
"token_configured": self.token is not None, "checkout_ready": True,
|
|
"current_commit": "a" * 40, "active_job_id": None,
|
|
}
|
|
|
|
def set_token(self, token):
|
|
self.token = token
|
|
|
|
def check(self):
|
|
return {
|
|
"repository": "https://g.luoli.live/root/virt.git", "branch": "main",
|
|
"current_commit": "a" * 40, "remote_commit": "b" * 40,
|
|
"status": "update_available",
|
|
}
|
|
|
|
def create_job(self, *, expected_current_commit=None, expected_remote_commit=None):
|
|
assert expected_current_commit == "a" * 40
|
|
assert expected_remote_commit == "b" * 40
|
|
self.job = {"job_id": "test-job-00000001", "status": "queued"}
|
|
return self.job
|
|
|
|
def get_job(self, job_id):
|
|
return self.job if self.job and job_id == self.job["job_id"] else None
|
|
|
|
def fail_job(self, job_id, error):
|
|
self.job = {"job_id": job_id, "status": "failed", "error": error}
|
|
|
|
monkeypatch.setattr(app_module, "Updater", FakeUpdater)
|
|
monkeypatch.setattr(app_module.subprocess, "run", lambda *args, **kwargs:
|
|
SimpleNamespace(returncode=0, stdout="inactive"))
|
|
with TestClient(app, base_url="https://panel.example.test") as client:
|
|
assert client.get("/api/v1/update/settings").status_code == 401
|
|
client.post("/api/v1/database/setup", json={
|
|
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
|
|
"username": "panel", "password": "test-database-password",
|
|
"setup_token": token,
|
|
})
|
|
response = client.post("/api/v1/setup/admin", json={
|
|
"token": token, "username": "admin",
|
|
"password": "correct-horse-battery-staple",
|
|
})
|
|
assert response.status_code == 200
|
|
store.users.promote("admin")
|
|
csrf = response.json()["csrf_token"]
|
|
assert client.put("/api/v1/update/settings", json={
|
|
"access_token": "some-very-private-gitea-token",
|
|
}).status_code == 403
|
|
saved = client.put("/api/v1/update/settings", json={
|
|
"access_token": "some-very-private-gitea-token",
|
|
}, headers={"X-CSRF-Token": csrf})
|
|
assert saved.status_code == 200
|
|
assert saved.json()["configured"] is True
|
|
assert "some-very-private-gitea-token" not in saved.text
|
|
checked = client.post("/api/v1/update/check", headers={
|
|
"X-CSRF-Token": csrf,
|
|
})
|
|
assert checked.status_code == 200
|
|
assert checked.json()["update_available"] is True
|
|
queued = client.post("/api/v1/update/apply", json={
|
|
"expected_current_commit": "a" * 40,
|
|
"expected_remote_commit": "b" * 40,
|
|
}, headers={
|
|
"X-CSRF-Token": csrf,
|
|
})
|
|
assert queued.status_code == 202
|
|
job_id = queued.json()["job_id"]
|
|
assert client.get(f"/api/v1/update/jobs/{job_id}").json()["status"] == "queued"
|
|
|
|
|
|
def test_vm_creation_finishes_before_update_is_queued(monkeypatch, tmp_path):
|
|
data_dir = tmp_path / "data"
|
|
store = MemoryStore()
|
|
vm_started = threading.Event()
|
|
release_vm = threading.Event()
|
|
update_received = threading.Event()
|
|
update_queued = threading.Event()
|
|
|
|
class ConfiguredManager(FakeManager):
|
|
def current(self):
|
|
return {"key_locked": False, "host": "host.example.test", "port": 22,
|
|
"fingerprint": "SHA256:test"}
|
|
|
|
class BlockingVMService:
|
|
def create_vm(self, spec):
|
|
vm_started.set()
|
|
assert release_vm.wait(timeout=5), "test did not release VM creation"
|
|
return {"uuid": spec["vm_uuid"]}
|
|
|
|
class FakeUpdater:
|
|
def __init__(self, _repo_dir, data_store):
|
|
self.store = data_store
|
|
self.job = None
|
|
|
|
def create_job(self, **_kwargs):
|
|
self.job = {"job_id": "test-job-00000001", "status": "queued"}
|
|
self.store.set_value("update.active_job", self.job["job_id"])
|
|
update_queued.set()
|
|
return self.job
|
|
|
|
def get_job(self, job_id):
|
|
return self.job if self.job and job_id == self.job["job_id"] else None
|
|
|
|
def fail_job(self, _job_id, _message):
|
|
raise AssertionError("the mocked update service must start")
|
|
|
|
monkeypatch.setattr(app_module, "make_components", lambda directory, *_: (
|
|
DatabasePanelState(directory, store, store.users), ConfiguredManager(),
|
|
DatabaseTemplateStore(store), store,
|
|
))
|
|
monkeypatch.setattr(app_module, "Updater", FakeUpdater)
|
|
monkeypatch.setattr(
|
|
app_module.subprocess, "run",
|
|
lambda argv, **_kwargs: SimpleNamespace(
|
|
returncode=3 if "is-active" in argv else 0,
|
|
stdout="inactive" if "is-active" in argv else "",
|
|
),
|
|
)
|
|
settings = Settings(data_dir=data_dir,
|
|
static_dir=Path(__file__).resolve().parents[1] / "static")
|
|
app = app_module.create_app(settings, service_factory=lambda _profile: BlockingVMService())
|
|
|
|
@app.middleware("http")
|
|
async def observe_update(request, call_next):
|
|
if request.url.path == "/api/v1/update/apply":
|
|
update_received.set()
|
|
return await call_next(request)
|
|
|
|
token = (data_dir / "setup-token").read_text(encoding="ascii").strip()
|
|
with TestClient(app, base_url="https://panel.example.test") as client:
|
|
configured = client.post("/api/v1/database/setup", json={
|
|
"host": "127.0.0.1", "port": 3306, "database": "virsh_panel",
|
|
"username": "panel", "password": "test-database-password",
|
|
"setup_token": token,
|
|
})
|
|
assert configured.status_code == 200
|
|
admin = client.post("/api/v1/setup/admin", json={
|
|
"token": token, "username": "admin",
|
|
"password": "correct-horse-battery-staple",
|
|
})
|
|
assert admin.status_code == 200
|
|
store.users.promote("admin")
|
|
headers = {"X-CSRF-Token": admin.json()["csrf_token"]}
|
|
with ThreadPoolExecutor(max_workers=2) as executor:
|
|
creating = executor.submit(client.post, "/api/v1/vms", json={
|
|
"name": "new-vm", "vcpu": 2, "memory_mib": 2048,
|
|
"disk_gib": 20, "network": "default", "iso": "AlmaLinux-10.iso",
|
|
}, headers=headers)
|
|
assert vm_started.wait(timeout=5)
|
|
updating = executor.submit(client.post, "/api/v1/update/apply", json={
|
|
"expected_current_commit": "a" * 40,
|
|
"expected_remote_commit": "b" * 40,
|
|
}, headers=headers)
|
|
try:
|
|
assert update_received.wait(timeout=5)
|
|
assert not update_queued.wait(timeout=0.2)
|
|
assert updating.result(timeout=1).status_code == 409
|
|
finally:
|
|
release_vm.set()
|
|
assert creating.result(timeout=5).status_code == 201
|
|
updating = client.post("/api/v1/update/apply", json={
|
|
"expected_current_commit": "a" * 40,
|
|
"expected_remote_commit": "b" * 40,
|
|
}, headers=headers)
|
|
assert updating.status_code == 202
|
|
assert update_queued.is_set()
|
|
blocked = client.post("/api/v1/vms", json={
|
|
"name": "another-vm", "vcpu": 2, "memory_mib": 2048,
|
|
"disk_gib": 20, "network": "default", "iso": "AlmaLinux-10.iso",
|
|
}, headers=headers)
|
|
assert blocked.status_code == 409
|