ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(manifest): push re-sync, drift check family, events (Phase 4)
Juan Denis8d61abbf2c13
diff --git a/backend/app/services/drift_service.py b/backend/app/services/drift_service.pyindex b2c492c5..51aef318 100644--- a/backend/app/services/drift_service.py+++ b/backend/app/services/drift_service.py@@ -442,6 +442,98 @@ register_check({'repair': _compose_repair,})+# ---------------------------------------------------------------------------+# manifest reconciliation (#18)+#+# Unlike the file-based checks above, this one compares *config*, not files:+# for every manifest-managed app it asks ManifestApplyService for the+# (expected, observed) pair over the manifest-declared surface (port,+# healthcheck, env keys, volumes, domains) and reports drift when they differ.+# Because there is no file on disk to read, we supply a custom ``read_actual``+# that re-derives the observed side instead of touching the filesystem. The+# synthetic path key is ``manifest://app/<id>``.+# ---------------------------------------------------------------------------+++def _manifest_list_resources():+ """Every Application that is governed by a stored manifest."""+ from app.models.application import Application+ from app.services.manifest_apply_service import ManifestApplyService++ out = []+ rows = Application.query.filter(Application.project_id.isnot(None)).all()+ for app in rows:+ try:+ if ManifestApplyService.resolved_for_app(app) is not None:+ out.append((app.id, app.name))+ except Exception: # noqa: BLE001 — skip apps we can't resolve+ continue+ return out+++def _manifest_render_expected(app_id):+ from app.models.application import Application+ from app.services.manifest_apply_service import ManifestApplyService++ app = Application.query.get(app_id)+ if app is None:+ return {}+ resolved = ManifestApplyService.resolved_for_app(app)+ if resolved is None:+ return {}+ expected, _observed = ManifestApplyService.drift_pair(app, resolved)+ return {f'manifest://app/{app_id}': json.dumps(expected, sort_keys=True)}+++def _manifest_read_actual(paths):+ from app.models.application import Application+ from app.services.manifest_apply_service import ManifestApplyService++ actual = {}+ for path in paths:+ try:+ app_id = int(path.rsplit('/', 1)[-1])+ except (ValueError, IndexError):+ actual[path] = None+ continue+ app = Application.query.get(app_id)+ resolved = ManifestApplyService.resolved_for_app(app) if app else None+ if app is None or resolved is None:+ actual[path] = None+ continue+ _expected, observed = ManifestApplyService.drift_pair(app, resolved)+ actual[path] = json.dumps(observed, sort_keys=True)+ return actual+++def _manifest_repair(app_id):+ from app.models.application import Application+ from app.services.manifest_apply_service import ManifestApplyService++ app = Application.query.get(app_id)+ if app is None:+ return {'success': False, 'error': f'Application {app_id} not found'}+ if not app.project_id:+ return {'success': False, 'error': f'Application {app_id} is not manifest-managed'}+ result = ManifestApplyService.apply_stored(app.project_id)+ ok = bool(result.get('success', False))+ return {+ 'success': ok,+ 'wrote': [f'app:{app_id}'],+ 'reloaded': ok,+ 'error': None if ok else result.get('error'),+ }+++register_check({+ 'type': 'manifest',+ 'title': 'Manifest reconciliation',+ 'list_resources': _manifest_list_resources,+ 'render_expected': _manifest_render_expected,+ 'read_actual': _manifest_read_actual,+ 'repair': _manifest_repair,+})+# NOTE: no systemd unit check — see the module docstring. The panel-templated# gunicorn units (PythonService.create_gunicorn_service) render from inputs# that aren't persisted (workers/user/.env snapshot), so an expected renderdiff --git a/backend/app/services/git_service.py b/backend/app/services/git_service.pyindex a122a91e..7d2138aa 100644--- a/backend/app/services/git_service.py+++ b/backend/app/services/git_service.py@@ -448,7 +448,22 @@ class GitService:pass# Trigger deployment- return cls.deploy(app_id)+ result = cls.deploy(app_id)++ # Push-to-reconfigure: re-read serverkit.yaml at the new commit and+ # reconcile (plan 17 #17). Best-effort — never affects the deploy result.+ try:+ from app.services.manifest_sync_service import ManifestSyncService+ commit = (payload.get('after')+ or (payload.get('head_commit') or {}).get('id'))+ manifest_sync = ManifestSyncService.resync_for_app(app_id, commit=commit,+ trigger='webhook')+ if isinstance(result, dict):+ result['manifest_sync'] = manifest_sync+ except Exception:+ pass++ return result@classmethoddef _log_deployment(cls, deploy_log: Dict) -> None:diff --git a/backend/app/services/manifest_apply_service.py b/backend/app/services/manifest_apply_service.pyindex 4e77f52d..75ada408 100644--- a/backend/app/services/manifest_apply_service.py+++ b/backend/app/services/manifest_apply_service.py@@ -83,6 +83,72 @@ class ManifestApplyService:'server': svc.get('server'),}+ # -- drift comparison (#18) --------------------------------------------++ @classmethod+ def resolved_for_app(cls, app) -> Optional[Dict[str, Any]]:+ """The normalized+resolved manifest service that governs ``app``, or None+ when the app is not manifest-managed."""+ if not getattr(app, 'project_id', None):+ return None+ row = ApplicationManifest.query.filter_by(project_id=app.project_id).first()+ if not row:+ return None+ normalized = row.get_normalized()+ if not normalized:+ return None+ svc = next((s for s in normalized.get('services', [])+ if s.get('name') == app.name and s.get('kind') == 'app'), None)+ if not svc:+ return None+ resolved = cls.resolve_service(svc)+ resolved['_domains'] = sorted(+ d['host'] for d in normalized.get('domains', [])+ if d.get('service') == app.name and d.get('host'))+ return resolved++ @classmethod+ def drift_pair(cls, app, resolved: Dict[str, Any]):+ """(expected, observed) dicts over ONLY the manifest-declared surface.++ The manifest is an overlay: extra live env vars/domains are not drift.+ We therefore project live state onto what the manifest declares, so the+ pair is equal iff every declared item is present and matches.+ """+ from app.models.env_variable import EnvironmentVariable+ expected: Dict[str, Any] = {}+ observed: Dict[str, Any] = {}++ if resolved.get('port') is not None:+ expected['port'] = resolved['port']+ observed['port'] = app.port+ if resolved.get('healthcheck_path'):+ expected['healthcheck_path'] = resolved['healthcheck_path']+ observed['healthcheck_path'] = app.healthcheck_path++ declared_env = sorted(list(resolved.get('env', {}).keys())+ + [r['key'] for r in resolved.get('env_refs', [])])+ if declared_env:+ live_keys = {ev.key for ev in+ EnvironmentVariable.query.filter_by(application_id=app.id).all()}+ expected['env_keys'] = declared_env+ observed['env_keys'] = sorted(k for k in declared_env if k in live_keys)++ declared_vols = sorted(d['mount_path'] for d in resolved.get('disks', [])+ if d.get('mount_path'))+ if declared_vols:+ live_mounts = {v.mount_path for v in (app.volumes or [])}+ expected['volumes'] = declared_vols+ observed['volumes'] = sorted(m for m in declared_vols if m in live_mounts)++ declared_domains = resolved.get('_domains', [])+ if declared_domains:+ live_hosts = {d.name for d in (app.domains or [])}+ expected['domains'] = declared_domains+ observed['domains'] = sorted(h for h in declared_domains if h in live_hosts)++ return expected, observed+# -- plan (#8) ----------------------------------------------------------@classmethod@@ -318,6 +384,18 @@ class ManifestApplyService:'plan': plan,}+ @classmethod+ def apply_stored(cls, project_id: int, user_id: Optional[int] = None) -> Dict[str, Any]:+ """Load and re-apply the manifest stored for a project (drift repair)."""+ project = Project.query.get(project_id)+ if not project:+ return {'success': False, 'error': 'project not found'}+ row = ApplicationManifest.query.filter_by(project_id=project_id).first()+ normalized = row.get_normalized() if row else None+ if not normalized:+ return {'success': False, 'error': 'no stored manifest'}+ return cls.apply(project, normalized, user_id=user_id, manifest_row=row)+@classmethoddef _execute_step(cls, project, env, step, user_id) -> Dict[str, Any]:stype = step['type']diff --git a/backend/app/services/manifest_sync_service.py b/backend/app/services/manifest_sync_service.pynew file mode 100644index 00000000..be2fe3bc--- /dev/null+++ b/backend/app/services/manifest_sync_service.py@@ -0,0 +1,129 @@+"""Push-to-reconfigure — re-read serverkit.yaml on every deploy (plan 17, Phase 4).++Both webhook receivers call ``resync_for_app`` after a deploy. If the manifest+hash is unchanged it is a no-op (today's behavior). If it changed, services with+``autoDeploy: true`` auto-apply (logged + snapshotted); anything else flips the+project's manifest to ``pending`` with a notification so push-to-deploy and+push-to-reconfigure become the same motion.++Fully guarded — a manifest problem must never break a deploy.+"""++import logging+from typing import Any, Dict, Optional++from app import db+from app.models.application import Application+from app.models.application_manifest import (+ ApplicationManifest, STATUS_PENDING, STATUS_APPLIED,+)+from app.models.project import Project+from app.services.manifest_persistence_service import ManifestPersistenceService++logger = logging.getLogger(__name__)+++class ManifestSyncService:++ @classmethod+ def resync_for_app(cls, app_id: int, commit: Optional[str] = None,+ trigger: str = 'webhook') -> Dict[str, Any]:+ """Re-read the repo manifest for an app's project and reconcile."""+ try:+ return cls._resync(app_id, commit, trigger)+ except Exception as exc: # never break a deploy+ logger.warning('Manifest resync failed for app %s: %s', app_id, exc)+ try:+ db.session.rollback()+ except Exception:+ pass+ return {'synced': False, 'error': str(exc)}++ @classmethod+ def _resync(cls, app_id: int, commit: Optional[str], trigger: str) -> Dict[str, Any]:+ from app.services.repository_manifest_service import RepositoryManifestService++ app = Application.query.get(app_id)+ if not app or not app.project_id or not app.root_path:+ return {'synced': False, 'reason': 'no project/root'}++ analysis = RepositoryManifestService.analyze_path(app.root_path)+ normalized = analysis.get('manifest_v1_normalized')+ if not normalized:+ return {'synced': False, 'reason': 'no v1 manifest'}++ new_hash = ManifestPersistenceService.hash_normalized(normalized)+ row = ApplicationManifest.query.filter_by(project_id=app.project_id).first()+ if row and row.manifest_hash == new_hash and row.status == STATUS_APPLIED:+ return {'synced': False, 'reason': 'unchanged'}++ project = Project.query.get(app.project_id)+ row = ManifestPersistenceService.store_manifest(+ project_id=project.id, normalized=normalized,+ raw_text=analysis.get('manifest_v1_raw'),+ source_commit=commit,+ source_path=analysis.get('manifest_v1_file') or 'serverkit.yaml',+ status=STATUS_PENDING)+ db.session.commit()++ services = normalized.get('services', [])+ auto = [s for s in services if s.get('auto_deploy')]+ has_manual = len(auto) < len(services)++ if not auto:+ # nothing opts into auto-apply — a plan is waiting+ cls._emit('manifest.pending', project, {+ 'reason': 'manifest changed; no autoDeploy services',+ 'commit': commit})+ return {'synced': True, 'action': 'pending', 'auto_applied': 0}++ from app.services.manifest_apply_service import ManifestApplyService+ auto_names = {s['name'] for s in auto}+ filtered = dict(normalized)+ filtered['services'] = auto+ filtered['domains'] = [d for d in normalized.get('domains', [])+ if not d.get('service') or d['service'] in auto_names]++ result = ManifestApplyService.apply(project, filtered, user_id=None,+ manifest_row=row)++ # if manual services still await, the manifest stays pending overall+ if has_manual and result.get('success'):+ row.status = STATUS_PENDING+ db.session.commit()+ cls._emit('manifest.pending', project, {+ 'reason': 'autoDeploy services applied; others await review',+ 'auto_applied': result.get('applied'), 'commit': commit})+ elif result.get('success'):+ cls._emit('manifest.applied', project, {+ 'applied': result.get('applied'), 'commit': commit,+ 'trigger': trigger})+ else:+ cls._emit('manifest.error', project, {+ 'commit': commit,+ 'error': next((r.get('error') for r in result.get('results', [])+ if r.get('status') == 'error'), None)})++ return {'synced': True, 'action': 'auto_apply',+ 'auto_applied': result.get('applied'), 'job_id': result.get('job_id'),+ 'success': result.get('success')}++ @staticmethod+ def _emit(event: str, project, data: Dict[str, Any]):+ """Best-effort admin notification (#19)."""+ try:+ from app.plugins_sdk import notify+ payload = {'project': project.name, 'project_id': project.id, **data}+ messages = {+ 'manifest.applied': f"Manifest for project “{project.name}” was applied "+ f"from a push ({data.get('applied', 0)} change(s)).",+ 'manifest.pending': f"Manifest for project “{project.name}” changed on a push "+ f"and is waiting for you to review and apply it.",+ 'manifest.drifted': f"Live state for project “{project.name}” no longer matches "+ f"its manifest.",+ 'manifest.error': f"Applying the manifest for project “{project.name}” failed.",+ }+ payload['message'] = messages.get(event, event)+ notify.send(event, to='admins', data=payload, category='deployments')+ except Exception as exc: # never break the flow+ logger.debug('manifest event %s not sent: %s', event, exc)diff --git a/backend/app/services/webhook_service.py b/backend/app/services/webhook_service.pyindex b86cee9a..46b4a6d4 100644--- a/backend/app/services/webhook_service.py+++ b/backend/app/services/webhook_service.py@@ -489,6 +489,13 @@ class WebhookService:actions.append('deployed')log.status = 'processed'log.status_message = f'Deployed v{deployment_result.get("version")} ({log.commit_sha[:7] if log.commit_sha else "unknown"})'+ # Push-to-reconfigure: re-read serverkit.yaml (plan 17 #17).+ try:+ from app.services.manifest_sync_service import ManifestSyncService+ ManifestSyncService.resync_for_app(+ webhook.app_id, commit=log.commit_sha, trigger='webhook')+ except Exception:+ passelse:log.status = 'failed'log.status_message = f'Deployment failed: {deployment_result.get("error")}'diff --git a/backend/tests/test_manifest_drift.py b/backend/tests/test_manifest_drift.pynew file mode 100644index 00000000..0e8e37f6--- /dev/null+++ b/backend/tests/test_manifest_drift.py@@ -0,0 +1,148 @@+"""Proving tests for the `manifest` drift check (plan 17, task #18).++The check compares live app config against the stored manifest (not files on+disk). We build a project, apply a tiny port+env manifest, persist it, then+exercise in_sync -> drifted -> repair -> in_sync.+"""++import pytest++import app.models.application_manifest # noqa: F401+from app.services.manifest_spec_service import ManifestSpecService+from app.services.manifest_apply_service import ManifestApplyService+from app.services.manifest_persistence_service import ManifestPersistenceService+++# port + single literal env only — no db, no volumes, no domains, so the apply+# needs neither Docker volume creation nor domain attachment.+MANIFEST = {+ 'version': 1,+ 'services': [+ {+ 'name': 'api', 'type': 'web', 'port': 8000,+ 'envVars': [{'key': 'LOG_LEVEL', 'value': 'info'}],+ },+ ],+}+++def owner(app):+ from app import db+ from app.models import User+ user = User.query.filter_by(username='testadmin').first()+ if not user:+ user = User(username='testadmin', email='[email protected]', role='admin')+ if hasattr(user, 'set_password'):+ user.set_password('admin')+ db.session.add(user)+ db.session.commit()+ return user+++def project(app):+ from app import db+ from app.models import Project, Environment+ from app.services.workspace_service import WorkspaceService+ ws = WorkspaceService.ensure_default_workspace()+ proj = Project(workspace_id=ws.id, name='Shop', slug='shop')+ db.session.add(proj)+ db.session.commit()+ env = Environment(project_id=proj.id, name='Production', slug='production',+ is_default=True)+ db.session.add(env)+ db.session.commit()+ return proj++[email protected](autouse=True)+def _stub_side_effects(monkeypatch):+ # Keep Docker/DNS out of the harness even though this manifest shouldn't+ # need them — belt and suspenders, mirrors test_manifest_apply.py.+ from app.services.docker_service import DockerService+ from app.services.domain_attach_service import DomainAttachService+ monkeypatch.setattr(DockerService, 'create_volume',+ classmethod(lambda cls, name, driver='local': {'success': True}))+ monkeypatch.setattr(DomainAttachService, 'attach',+ classmethod(lambda cls, app, host, ssl='auto', email=None,+ make_primary=False: {'success': True, 'domain': host,+ 'created': True, 'warnings': []}))+++def applied(project, owner):+ """Apply + persist the manifest; return (project, owner, app)."""+ from app import db+ from app.models import Application+ n = ManifestSpecService.normalize(MANIFEST)+ result = ManifestApplyService.apply(project, n, user_id=owner.id)+ assert result['success'] is True, result+ # Calling the service directly does not store the manifest; persist it so+ # resolved_for_app can find it.+ ManifestPersistenceService.store_manifest(project.id, n)+ db.session.commit()+ api = Application.query.filter_by(project_id=project.id, name='api').first()+ assert api is not None+ return project, owner, api+++def _find_manifest_check():+ from app.services.drift_service import DRIFT_CHECKS+ return DRIFT_CHECKS['manifest']+++def _resource_for_app(check, app_id):+ for rid, name in check['list_resources']():+ if rid == app_id:+ return rid, name+ return None, None+++def test_check_reports_in_sync_after_apply(applied):+ from app.services.drift_service import DriftService+ _project, _owner, api = applied+ check = _find_manifest_check()++ rid, name = _resource_for_app(check, api.id)+ assert rid == api.id, 'manifest-managed app should be listed'++ entry = DriftService.check_resource(check, rid, name)+ assert entry['status'] == 'in_sync', entry+++def test_check_detects_drift(applied):+ from app import db+ from app.services.drift_service import DriftService+ _project, _owner, api = applied+ check = _find_manifest_check()++ # Mutate live state out from under the manifest.+ api.port = 9999+ db.session.commit()++ rid, name = _resource_for_app(check, api.id)+ entry = DriftService.check_resource(check, rid, name)+ assert entry['status'] == 'drifted', entry+++def test_repair_reconverges(applied):+ from app import db+ from app.services.drift_service import DriftService+ _project, _owner, api = applied+ check = _find_manifest_check()+ app_id = api.id++ api.port = 9999+ db.session.commit()++ rid, name = _resource_for_app(check, app_id)+ assert DriftService.check_resource(check, rid, name)['status'] == 'drifted'++ result = DriftService.repair('manifest', app_id)+ assert result['success'] is True, result++ # re-list + re-check; live state should match the manifest again.+ rid, name = _resource_for_app(check, app_id)+ entry = DriftService.check_resource(check, rid, name)+ assert entry['status'] == 'in_sync', entrydiff --git a/backend/tests/test_manifest_sync.py b/backend/tests/test_manifest_sync.pynew file mode 100644index 00000000..2aaa202e--- /dev/null+++ b/backend/tests/test_manifest_sync.py@@ -0,0 +1,115 @@+"""Proving tests for Phase 4 — push re-sync + events (plan 17)."""++import pytest+import yaml++import app.models.application_manifest # noqa: F401+from app.services.manifest_sync_service import ManifestSyncService+++def owner(app):+ from app import db+ from app.models import User+ user = User.query.filter_by(username='testadmin').first()+ if not user:+ user = User(username='testadmin', email='[email protected]', role='admin')+ db.session.add(user)+ db.session.commit()+ return user+++def project(app):+ from app import db+ from app.models import Project, Environment+ from app.services.workspace_service import WorkspaceService+ ws = WorkspaceService.ensure_default_workspace()+ proj = Project(workspace_id=ws.id, name='Sync', slug='sync')+ db.session.add(proj)+ db.session.commit()+ env = Environment(project_id=proj.id, name='Prod', slug='prod', is_default=True)+ db.session.add(env)+ db.session.commit()+ return proj+++def _app_with_repo(project, owner, tmp_path, manifest_dict):+ from app import db+ from app.models import Application+ (tmp_path / 'serverkit.yaml').write_text(yaml.safe_dump(manifest_dict), encoding='utf-8')+ a = Application(name='api', app_type='docker', port=8000, user_id=owner.id,+ project_id=project.id, root_path=str(tmp_path), status='running')+ db.session.add(a)+ db.session.commit()+ return a+++def events(monkeypatch):+ captured = []+ from app.plugins_sdk import notify+ monkeypatch.setattr(notify, 'send',+ lambda event, to=None, data=None, **kw: captured.append((event, data)))+ return captured+++def test_autodeploy_service_auto_applies(project, owner, tmp_path, events):+ m = {'version': 1, 'services': [+ {'name': 'api', 'type': 'web', 'port': 9100, 'autoDeploy': True,+ 'envVars': [{'key': 'LOG_LEVEL', 'value': 'debug'}]}]}+ a = _app_with_repo(project, owner, tmp_path, m)++ result = ManifestSyncService.resync_for_app(a.id, commit='deadbeef')+ assert result['synced'] is True+ assert result['action'] == 'auto_apply'++ from app.models.application_manifest import ApplicationManifest+ row = ApplicationManifest.query.filter_by(project_id=project.id).first()+ assert row.status == 'applied'+ assert row.source_commit == 'deadbeef'+ # port change from the manifest was applied+ from app.models import Application+ assert Application.query.get(a.id).port == 9100+ assert any(e[0] == 'manifest.applied' for e in events)+++def test_no_autodeploy_flips_pending(project, owner, tmp_path, events):+ m = {'version': 1, 'services': [+ {'name': 'api', 'type': 'web', 'port': 9100}]} # autoDeploy defaults false+ a = _app_with_repo(project, owner, tmp_path, m)++ result = ManifestSyncService.resync_for_app(a.id, commit='c1')+ assert result['action'] == 'pending'+ from app.models.application_manifest import ApplicationManifest+ row = ApplicationManifest.query.filter_by(project_id=project.id).first()+ assert row.status == 'pending'+ # not applied: port unchanged+ from app.models import Application+ assert Application.query.get(a.id).port == 8000+ assert any(e[0] == 'manifest.pending' for e in events)+++def test_unchanged_hash_is_noop(project, owner, tmp_path, events):+ m = {'version': 1, 'services': [+ {'name': 'api', 'type': 'web', 'port': 9100, 'autoDeploy': True}]}+ a = _app_with_repo(project, owner, tmp_path, m)++ first = ManifestSyncService.resync_for_app(a.id, commit='c1')+ assert first['synced'] is True+ second = ManifestSyncService.resync_for_app(a.id, commit='c2')+ assert second['synced'] is False+ assert second['reason'] == 'unchanged'+++def test_no_manifest_is_noop(project, owner, tmp_path):+ from app import db+ from app.models import Application+ # repo dir with no serverkit.yaml+ a = Application(name='api', app_type='docker', user_id=owner.id,+ project_id=project.id, root_path=str(tmp_path), status='running')+ db.session.add(a)+ db.session.commit()+ result = ManifestSyncService.resync_for_app(a.id)+ assert result['synced'] is False+ assert result['reason'] == 'no v1 manifest'