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
refactor(unify): §8 Phase B2 — database + files executors in policy service
Juan Denisf357742d807d
diff --git a/backend/app/services/backup_policy_service.py b/backend/app/services/backup_policy_service.pyindex 34e0dfd2..def9fe79 100644--- a/backend/app/services/backup_policy_service.py+++ b/backend/app/services/backup_policy_service.py@@ -202,7 +202,8 @@ class BackupPolicyService:def _resolve_target(cls, policy):"""Return a dict describing the live target, or raise if missing.- keys: name, root_path, target_type, site (wp only), app, db_config (wp).+ keys: name, root_path, target_type, site (wp only), app, plus+ db_config (database) / file_paths (files) for the non-resource targets."""if policy.target_type == 'wordpress_site':from app.models.wordpress_site import WordPressSite@@ -216,6 +217,38 @@ class BackupPolicyService:'name': app.name, 'root_path': app.root_path,'target_type': 'wordpress_site', 'site': site, 'app': app,}++ if policy.target_type == 'database':+ meta = policy.get_target_meta()+ db_name = meta.get('db_name')+ if not db_name:+ raise BackupPolicyError('Database target is missing db_name')+ return {+ 'name': db_name, 'root_path': None,+ 'target_type': 'database', 'site': None, 'app': None,+ 'db_config': {+ 'db_type': policy.target_subtype or meta.get('db_type') or 'mysql',+ 'db_name': db_name,+ 'user': meta.get('user'),+ 'password': meta.get('password'),+ 'host': meta.get('host', 'localhost'),+ },+ }++ if policy.target_type == 'files':+ meta = policy.get_target_meta()+ file_paths = meta.get('paths') or []+ if not file_paths:+ raise BackupPolicyError('Files target has no paths configured')+ return {+ 'name': meta.get('label') or f'files-{policy.target_id}',+ 'root_path': None, 'target_type': 'files',+ 'site': None, 'app': None, 'file_paths': list(file_paths),+ }++ if policy.target_type == 'server':+ raise BackupPolicyError('Whole-server backups are not yet implemented')+# applicationfrom app.models.application import Applicationapp = Application.query.get(policy.target_id)@@ -303,6 +336,42 @@ class BackupPolicyService:})return storage_path, size, meta+ if target['target_type'] == 'database':+ from app.services.backup_service import BackupService+ cfg = target['db_config']+ result = BackupService.backup_database(+ db_type=cfg['db_type'], db_name=cfg['db_name'],+ user=cfg.get('user'), password=cfg.get('password'),+ host=cfg.get('host', 'localhost'),+ )+ if not result.get('success'):+ raise BackupPolicyError(result.get('error') or 'Database backup failed')+ backup = result.get('backup') or {}+ storage_path = backup.get('path')+ size = backup.get('size') or cls._path_size(storage_path)+ meta.update({+ 'kind': 'full', 'compression': 'gzip', 'incremental': False,+ 'includes': ['database'], 'backup_name': backup.get('name'),+ 'primary_archive': storage_path,+ 'db_type': cfg['db_type'], 'db_name': cfg['db_name'],+ })+ return storage_path, size, meta++ if target['target_type'] == 'files':+ from app.services.backup_service import BackupService+ result = BackupService.backup_files(target['file_paths'], target['name'])+ if not result.get('success'):+ raise BackupPolicyError(result.get('error') or 'File backup failed')+ backup = result.get('backup') or {}+ storage_path = result.get('path') or backup.get('path')+ size = backup.get('size') or cls._path_size(storage_path)+ meta.update({+ 'kind': 'full', 'compression': 'gzip', 'incremental': False,+ 'includes': ['files'], 'backup_name': backup.get('name'),+ 'primary_archive': storage_path, 'paths': target['file_paths'],+ })+ return storage_path, size, meta+# application — smart incremental + compression tieringfrom app.models.backup_run import BackupRunfrom app.services.backup_service import BackupService@@ -589,6 +658,10 @@ class BackupPolicyService:if target['target_type'] == 'wordpress_site':cls._restore_wordpress(target, run, scope, payload)+ elif target['target_type'] == 'database':+ cls._restore_database(target, run)+ elif target['target_type'] == 'files':+ cls._restore_files(target, run, payload)else:cls._restore_application(policy, target, run, scope)@@ -659,6 +732,41 @@ class BackupPolicyService:if not result.get('success'):raise BackupPolicyError(result.get('error') or 'Restore failed')+ @classmethod+ def _restore_database(cls, target, run):+ """Restore a standalone database from its dump (mysql/postgres/etc.)."""+ from app.services.backup_service import BackupService+ cfg = target['db_config']+ backup_path = (run.get_metadata() or {}).get('primary_archive') or run.storage_path+ if not backup_path or not os.path.exists(backup_path):+ raise BackupPolicyError('Backup archive not found')+ result = BackupService.restore_database(+ backup_path=backup_path, db_type=cfg['db_type'], db_name=cfg['db_name'],+ user=cfg.get('user'), password=cfg.get('password'),+ host=cfg.get('host', 'localhost'),+ )+ if not result.get('success'):+ raise BackupPolicyError(result.get('error') or 'Database restore failed')++ @classmethod+ def _restore_files(cls, target, run, payload):+ """Extract a files backup. Restores into an explicit ``restore_path``+ (from options) or a safe ``restores/`` staging dir — never blindly over+ the originals, since a path-list archive only preserves basenames."""+ import tarfile+ from app.services.backup_service import BackupService+ backup_path = (run.get_metadata() or {}).get('primary_archive') or run.storage_path+ if not backup_path or not os.path.exists(backup_path):+ raise BackupPolicyError('Backup archive not found')+ dest = (payload or {}).get('restore_path')+ if not dest:+ dest = os.path.join(BackupService.BACKUP_BASE_DIR, 'restores',+ f'files-{run.id}')+ os.makedirs(dest, exist_ok=True)+ with tarfile.open(backup_path, 'r:gz') as tar:+ tar.extractall(dest, filter='data')+ return {'restore_path': dest}+@classmethoddef _chain_archives(cls, policy, run):"""Ordered list of local archive paths needed to restore ``run`` — thediff --git a/backend/tests/test_backup_db_files_executors.py b/backend/tests/test_backup_db_files_executors.pynew file mode 100644index 00000000..97f1c262--- /dev/null+++ b/backend/tests/test_backup_db_files_executors.py@@ -0,0 +1,125 @@+"""§8 Phase B2 — database + files executors in the unified backup service.++Verifies that BackupPolicyService routes database/files targets to the right+BackupService primitives and builds correct run metadata, without needing a+live database or real archives (BackupService is mocked).+"""+import pytest++from app.services.backup_policy_service import BackupPolicyService, BackupPolicyError+++# --- target resolution ----------------------------------------------------- #++def test_resolve_database_target(app):+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy(+ 'database', 7, target_subtype='postgresql',+ target_meta={'db_name': 'shop', 'user': 'app', 'host': 'db1'},+ )+ target = BackupPolicyService._resolve_target(policy)+ assert target['target_type'] == 'database'+ assert target['name'] == 'shop'+ assert target['db_config']['db_type'] == 'postgresql' # from subtype+ assert target['db_config']['db_name'] == 'shop'+ assert target['db_config']['host'] == 'db1'+++def test_resolve_database_requires_db_name(app):+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy('database', 8, target_meta={})+ with pytest.raises(BackupPolicyError):+ BackupPolicyService._resolve_target(policy)+++def test_resolve_files_target(app):+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy(+ 'files', 3, target_meta={'paths': ['/etc/nginx', '/srv/data'], 'label': 'configs'},+ )+ target = BackupPolicyService._resolve_target(policy)+ assert target['target_type'] == 'files'+ assert target['name'] == 'configs'+ assert target['file_paths'] == ['/etc/nginx', '/srv/data']+++def test_resolve_files_requires_paths(app):+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy('files', 4, target_meta={'paths': []})+ with pytest.raises(BackupPolicyError):+ BackupPolicyService._resolve_target(policy)+++def test_resolve_server_not_implemented(app):+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy('server', 1)+ with pytest.raises(BackupPolicyError):+ BackupPolicyService._resolve_target(policy)+++# --- execution routing (BackupService mocked) ------------------------------ #++def test_execute_database_backup_routes_and_builds_meta(app, monkeypatch):+ from app.services.backup_service import BackupService+ calls = {}++ def fake_backup_database(db_type, db_name, user=None, password=None, host='localhost'):+ calls['db'] = (db_type, db_name, user, host)+ return {'success': True, 'backup': {'name': f'{db_name}.sql.gz',+ 'path': '/var/backups/databases/shop.sql.gz',+ 'size': 4096}}++ monkeypatch.setattr(BackupService, 'backup_database', staticmethod(fake_backup_database))+ monkeypatch.setattr(BackupPolicyService, '_path_size', staticmethod(lambda p: 4096))++ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy(+ 'database', 11, target_subtype='mysql', target_meta={'db_name': 'shop'},+ )+ target = BackupPolicyService._resolve_target(policy)+ storage_path, size, meta = BackupPolicyService._execute_backup(policy, target, 'full')++ assert calls['db'][0] == 'mysql'+ assert calls['db'][1] == 'shop'+ assert storage_path.endswith('shop.sql.gz')+ assert size == 4096+ assert meta['includes'] == ['database']+ assert meta['kind'] == 'full'+ assert meta['primary_archive'] == storage_path+++def test_execute_files_backup_routes_and_builds_meta(app, monkeypatch):+ from app.services.backup_service import BackupService+ calls = {}++ def fake_backup_files(file_paths, backup_name=None):+ calls['files'] = (list(file_paths), backup_name)+ return {'success': True, 'path': '/var/backups/files/configs_x.tar.gz',+ 'backup': {'name': 'configs_x.tar.gz', 'size': 2048}}++ monkeypatch.setattr(BackupService, 'backup_files', staticmethod(fake_backup_files))++ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy(+ 'files', 12, target_meta={'paths': ['/etc/nginx'], 'label': 'configs'},+ )+ target = BackupPolicyService._resolve_target(policy)+ storage_path, size, meta = BackupPolicyService._execute_backup(policy, target, 'full')++ assert calls['files'][0] == ['/etc/nginx']+ assert storage_path.endswith('configs_x.tar.gz')+ assert size == 2048+ assert meta['includes'] == ['files']+ assert meta['paths'] == ['/etc/nginx']+++def test_execute_database_backup_propagates_failure(app, monkeypatch):+ from app.services.backup_service import BackupService+ monkeypatch.setattr(BackupService, 'backup_database',+ staticmethod(lambda **kw: {'success': False, 'error': 'mysqldump missing'}))+ with app.app_context():+ policy = BackupPolicyService.get_or_create_policy(+ 'database', 13, target_subtype='mysql', target_meta={'db_name': 'x'})+ target = BackupPolicyService._resolve_target(policy)+ with pytest.raises(BackupPolicyError):+ BackupPolicyService._execute_backup(policy, target, 'full')