You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
190 lines
8.8 KiB
190 lines
8.8 KiB
import copy
|
|
import json
|
|
from pathlib import Path
|
|
import tarfile
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
|
|
from updater import CAPABILITY_LABEL, UpdateError, Updater, validate_image
|
|
|
|
|
|
class FakeDocker:
|
|
def __init__(self, data):
|
|
self.calls = []
|
|
self.fail = None
|
|
self.new_health = "healthy"
|
|
self.pull_started = threading.Event()
|
|
self.release_pull = threading.Event()
|
|
self.release_pull.set()
|
|
self.current = {
|
|
"Id": "container-before", "Image": "sha256:old",
|
|
"Config": {"Image": "example/vaultwarden:old", "Env": [], "Labels": {
|
|
"com.docker.compose.project": "vault-test", "com.docker.compose.service": "vaultwarden",
|
|
"com.docker.compose.config-hash": "test-config-hash",
|
|
}},
|
|
"Mounts": [{"Destination": "/data", "Source": str(data), "Type": "bind", "RW": True}],
|
|
"State": {"Running": True, "Health": {"Status": "healthy"}},
|
|
}
|
|
self.image = {"Id": "sha256:new", "Config": {
|
|
"Labels": {CAPABILITY_LABEL: "1"}, "Healthcheck": {"Test": ["CMD", "/healthcheck"]},
|
|
}}
|
|
|
|
def run(self, *args, timeout=60):
|
|
self.calls.append(args)
|
|
if args[0] == "pull":
|
|
self.pull_started.set()
|
|
if not self.release_pull.wait(5):
|
|
raise RuntimeError("Test pull timed out")
|
|
if self.fail == "pull":
|
|
raise UpdateError("Image download failed.")
|
|
return ""
|
|
if args[:2] == ("image", "inspect"):
|
|
return json.dumps([self.image])
|
|
if args[0] == "inspect":
|
|
return json.dumps([self.current])
|
|
if "ps" in args:
|
|
return self.current["Id"]
|
|
if "--hash" in args:
|
|
return "vaultwarden test-config-hash"
|
|
if "stop" in args:
|
|
self.current["State"]["Running"] = False
|
|
return ""
|
|
if "up" in args:
|
|
if self.fail == "up":
|
|
raise UpdateError("Container recreation failed.")
|
|
self.current["Id"] = "container-after"
|
|
self.current["Image"] = self.image["Id"]
|
|
self.current["State"] = {"Running": True, "Health": {"Status": self.new_health}}
|
|
return ""
|
|
raise AssertionError(args)
|
|
|
|
|
|
class UpdateFlowTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temporary = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.temporary.cleanup)
|
|
self.root = Path(self.temporary.name)
|
|
self.data = self.root / "data"
|
|
self.data.mkdir()
|
|
(self.data / "db.sqlite3").write_bytes(b"original database")
|
|
(self.data / "attachments").mkdir()
|
|
(self.data / "attachments" / "file").write_bytes(b"original attachment")
|
|
self.state = self.root / "state"
|
|
self.state.mkdir()
|
|
self.compose = self.root / "compose.json"
|
|
self.compose.write_text("{}")
|
|
self.config = {
|
|
"state_directory": str(self.state), "data_directory": str(self.data),
|
|
"project_directory": str(self.root), "project": "vault-test", "service": "vaultwarden",
|
|
"compose_files": [str(self.compose)], "default_image": "example/vaultwarden:latest",
|
|
"image_repositories": ["example/vaultwarden"], "health_timeout": 1,
|
|
}
|
|
self.docker = FakeDocker(self.data)
|
|
self.updater = Updater(self.config, self.docker)
|
|
|
|
def run_update(self):
|
|
self.updater.state["busy"] = True
|
|
self.updater.work(self.updater.update)
|
|
return self.updater.status()
|
|
|
|
def test_success_backs_up_data_and_deploys_downloaded_id(self):
|
|
state = self.run_update()
|
|
self.assertEqual(state["result"], "updated")
|
|
self.assertFalse(state["recovery_required"])
|
|
archive_path, = self.state.glob("backups/*/data.tar")
|
|
with tarfile.open(archive_path) as archive:
|
|
self.assertEqual(archive.extractfile("data/db.sqlite3").read(), b"original database")
|
|
self.assertEqual(archive.extractfile("data/attachments/file").read(), b"original attachment")
|
|
override = json.loads(self.updater.override.read_text())
|
|
self.assertEqual(override["services"]["vaultwarden"]["image"], "sha256:new")
|
|
up, = [call for call in self.docker.calls if "up" in call]
|
|
self.assertIn("--no-deps", up)
|
|
self.assertIn("never", up)
|
|
|
|
def test_download_failure_keeps_running_service_and_data(self):
|
|
self.docker.fail = "pull"
|
|
state = self.run_update()
|
|
self.assertEqual(state["result"], "failed")
|
|
self.assertFalse(state["recovery_required"])
|
|
self.assertTrue(self.docker.current["State"]["Running"])
|
|
self.assertFalse(any("stop" in call for call in self.docker.calls))
|
|
self.assertFalse(self.updater.override.exists())
|
|
|
|
def test_same_image_does_not_restart(self):
|
|
self.docker.image["Id"] = self.docker.current["Image"]
|
|
self.assertEqual(self.run_update()["result"], "unchanged")
|
|
self.assertFalse(any("stop" in call for call in self.docker.calls))
|
|
|
|
def test_image_without_update_feature_is_rejected_before_stop(self):
|
|
self.docker.image["Config"]["Labels"] = {}
|
|
self.assertEqual(self.run_update()["result"], "failed")
|
|
self.assertFalse(any("stop" in call for call in self.docker.calls))
|
|
|
|
def test_unapplied_compose_changes_are_rejected_before_stop(self):
|
|
self.docker.current["Config"]["Labels"]["com.docker.compose.config-hash"] = "different-config"
|
|
self.assertEqual(self.run_update()["result"], "failed")
|
|
self.assertFalse(any("stop" in call for call in self.docker.calls))
|
|
|
|
def test_external_database_and_data_mounts_are_rejected(self):
|
|
original = copy.deepcopy(self.docker.current)
|
|
for environment in (["DATABASE_URL=postgresql://database/vault"], ["ATTACHMENTS_FOLDER=/external"],
|
|
["DATABASE_URL_FILE=/run/secrets/database"], ["ENV_FILE=/config/.env"]):
|
|
self.docker.current = copy.deepcopy(original)
|
|
self.docker.current["Config"]["Env"] = environment
|
|
with self.assertRaises(UpdateError):
|
|
self.updater.preflight(self.docker.current)
|
|
self.docker.current = original
|
|
self.docker.current["Mounts"].append({"Destination": "/external", "RW": True})
|
|
with self.assertRaises(UpdateError):
|
|
self.updater.preflight(self.docker.current)
|
|
|
|
def test_recreation_and_health_failures_preserve_backup_and_block_retry(self):
|
|
for failure in ("up", "health"):
|
|
with self.subTest(failure=failure):
|
|
self.docker.current["State"] = {"Running": True, "Health": {"Status": "healthy"}}
|
|
self.docker.current["Image"] = "sha256:old"
|
|
self.docker.fail = failure
|
|
self.docker.new_health = "unhealthy"
|
|
state = self.run_update()
|
|
self.assertTrue(state["recovery_required"])
|
|
self.assertEqual(state["result"], "failed")
|
|
self.assertTrue(list(self.state.glob("backups/*/data.tar")))
|
|
with self.assertRaises(UpdateError):
|
|
self.updater.submit()
|
|
self.assertEqual((self.data / "db.sqlite3").read_bytes(), b"original database")
|
|
|
|
def test_duplicate_requests_are_rejected_while_updating(self):
|
|
self.docker.release_pull.clear()
|
|
self.updater.submit()
|
|
self.assertTrue(self.docker.pull_started.wait(2))
|
|
try:
|
|
with self.assertRaises(UpdateError):
|
|
self.updater.submit()
|
|
finally:
|
|
self.docker.release_pull.set()
|
|
# Join this updater's non-daemon worker before temporary data is removed.
|
|
for thread in threading.enumerate():
|
|
if thread is not threading.current_thread() and not thread.daemon:
|
|
thread.join(5)
|
|
self.assertEqual(self.updater.status()["result"], "updated")
|
|
|
|
def test_interrupted_update_stays_blocked_after_restart(self):
|
|
self.updater.event("Stopping…", busy=True, recovery_required=True)
|
|
restarted = Updater(self.config, self.docker)
|
|
self.assertFalse(restarted.status()["busy"])
|
|
self.assertTrue(restarted.status()["recovery_required"])
|
|
with self.assertRaises(UpdateError):
|
|
restarted.submit()
|
|
|
|
def test_repository_and_tag_validation(self):
|
|
allowed = ["registry.example.com/vaultwarden", "localhost:5000/vaultwarden"]
|
|
for image in ("registry.example.com/vaultwarden:latest", "localhost:5000/vaultwarden:v1", "registry.example.com/vaultwarden@sha256:" + "a" * 64):
|
|
self.assertEqual(validate_image(image, allowed), image)
|
|
for image in ("--help", "registry.example.com/vaultwarden", "evil/vaultwarden:latest", "registry.example.com/vaultwarden:latest;id"):
|
|
with self.assertRaises(UpdateError):
|
|
validate_image(image, allowed)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|
|
|