Skip to content

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.

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.py
index 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')
+
# application
from app.models.application import Application
app = 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 tiering
from app.models.backup_run import BackupRun
from 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}
+
@classmethod
def _chain_archives(cls, policy, run):
"""Ordered list of local archive paths needed to restore ``run`` — the
diff --git a/backend/tests/test_backup_db_files_executors.py b/backend/tests/test_backup_db_files_executors.py
new file mode 100644
index 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')