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.

feat(restore-points): add surface adapters and checkpoints

Juan Deniscf2cce6041c9
diff --git a/backend/app/__init__.py b/backend/app/__init__.py
index 42615db6..75ec993a 100644
--- a/backend/app/__init__.py
+++ b/backend/app/__init__.py
@@ -220,6 +220,11 @@ def create_app(config_name=None):
from app.services import recycle_bin_service
recycle_bin_service.register_builtin_types()
+ # Restore adapters are process-local strategy registrations. They do not
+ # touch the database and must exist in testing/CLI app factories too.
+ from app.services.restore_point_adapters import register_builtin_restore_point_adapters
+ register_builtin_restore_point_adapters()
+
# Handle database migrations (Alembic) — must run before plugin loader
# since the loader queries the installed_plugins table.
with app.app_context():
diff --git a/backend/app/api/cron.py b/backend/app/api/cron.py
index b0cef45b..902ba33b 100644
--- a/backend/app/api/cron.py
+++ b/backend/app/api/cron.py
@@ -231,14 +231,11 @@ def toggle_tracking(job_id):
serverkit-cron-run shim; disabling restores the bare command)."""
data = request.get_json(silent=True) or {}
enabled = bool(data.get('enabled', True))
- result = CronService.set_tracking(job_id, enabled)
+ options = {}
+ if 'alert_on_failure' in data:
+ options['alert_on_failure'] = data['alert_on_failure']
+ result = CronService.set_tracking(job_id, enabled, **options)
if result.get('success'):
- # Persist the optional per-job "alert on failure" flag alongside.
- if 'alert_on_failure' in data:
- meta = CronService._load_jobs_metadata()
- if job_id in meta.get('jobs', {}):
- meta['jobs'][job_id]['alert_on_failure'] = bool(data['alert_on_failure'])
- CronService._save_jobs_metadata(meta)
return jsonify(result)
return jsonify(result), 400
diff --git a/backend/app/api/env_vars.py b/backend/app/api/env_vars.py
index 2be61b1a..5d8f4e96 100644
--- a/backend/app/api/env_vars.py
+++ b/backend/app/api/env_vars.py
@@ -127,36 +127,21 @@ def update_env_var(app_id, key):
if not data:
return jsonify({'error': 'No data provided'}), 400
- value = data.get('value')
- is_secret = data.get('is_secret')
- description = data.get('description')
-
- # Get existing
- existing = EnvService.get_env_var(app_id, key)
- if not existing:
- return jsonify({'error': 'Environment variable not found'}), 404
-
- # Update only provided fields
- if value is not None:
- old_value = existing.value
- existing.value = value
- from app.models import EnvironmentVariableHistory
- from app import db
- EnvironmentVariableHistory.record_change(
- existing, 'updated', old_value=old_value, new_value=value, user_id=current_user_id
- )
-
- if is_secret is not None:
- existing.is_secret = is_secret
-
- if description is not None:
- existing.description = description
-
+ updates = {}
+ if data.get('value') is not None:
+ updates['value'] = data['value']
+ if data.get('is_secret') is not None:
+ updates['is_secret'] = data['is_secret']
+ if data.get('description') is not None:
+ updates['description'] = data['description']
if 'target_service' in data:
- existing.target_service = data.get('target_service') or None
+ updates['target_service'] = data.get('target_service')
- from app import db
- db.session.commit()
+ existing, err = EnvService.update_env_var(
+ app_id, key, user_id=current_user_id, **updates,
+ )
+ if err:
+ return jsonify({'error': err}), 404
return jsonify({
'message': 'Environment variable updated',
diff --git a/backend/app/models/dns_change.py b/backend/app/models/dns_change.py
index fea7ea8e..4062f188 100644
--- a/backend/app/models/dns_change.py
+++ b/backend/app/models/dns_change.py
@@ -22,10 +22,10 @@ class DnsChange(SerializableMixin, db.Model):
record_type = db.Column(db.String(10))
name = db.Column(db.String(256))
content = db.Column(db.Text) # value we set (after)
+ before_json = db.Column(db.Text) # complete owned pre-image
provider_record_id = db.Column(db.String(128))
source = db.Column(db.String(40)) # zone|ddns|wordpress|email|auto-dns|caa|...
result = db.Column(db.String(16), nullable=False) # ok | error | conflict | skipped
error = db.Column(db.Text)
created_at = db.Column(db.DateTime, default=datetime.utcnow, index=True)
-
diff --git a/backend/app/models/env_variable.py b/backend/app/models/env_variable.py
index b81f7198..27823221 100644
--- a/backend/app/models/env_variable.py
+++ b/backend/app/models/env_variable.py
@@ -140,6 +140,10 @@ class EnvironmentVariableHistory(db.Model):
action = db.Column(db.String(20), nullable=False) # 'created', 'updated', 'deleted'
old_value_hash = db.Column(db.String(64), nullable=True) # SHA256 hash (not the actual value)
new_value_hash = db.Column(db.String(64), nullable=True)
+ # One logical operation (bulk import, clear, or restore replay) may write
+ # several per-variable audit rows. ``batch_id`` keeps those rows grouped
+ # without weakening the existing one-row-per-key history.
+ batch_id = db.Column(db.String(36), nullable=True, index=True)
changed_by = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
changed_at = db.Column(db.DateTime, default=datetime.utcnow)
@@ -151,7 +155,8 @@ class EnvironmentVariableHistory(db.Model):
return hashlib.sha256(value.encode()).hexdigest()
@classmethod
- def record_change(cls, env_var, action, old_value=None, new_value=None, user_id=None):
+ def record_change(cls, env_var, action, old_value=None, new_value=None,
+ user_id=None, batch_id=None):
"""Record a change to an environment variable."""
history = cls(
env_variable_id=env_var.id if env_var.id else 0,
@@ -160,7 +165,8 @@ class EnvironmentVariableHistory(db.Model):
action=action,
old_value_hash=cls.hash_value(old_value) if old_value else None,
new_value_hash=cls.hash_value(new_value) if new_value else None,
- changed_by=user_id
+ batch_id=batch_id,
+ changed_by=user_id,
)
db.session.add(history)
return history
@@ -172,6 +178,7 @@ class EnvironmentVariableHistory(db.Model):
'application_id': self.application_id,
'key': self.key,
'action': self.action,
+ 'batch_id': self.batch_id,
'changed_by': self.changed_by,
'changed_at': self.changed_at.isoformat() if self.changed_at else None,
}
diff --git a/backend/app/models/managed_dns_record.py b/backend/app/models/managed_dns_record.py
index 3edf1405..05d38b6f 100644
--- a/backend/app/models/managed_dns_record.py
+++ b/backend/app/models/managed_dns_record.py
@@ -26,6 +26,12 @@ class ManagedDnsRecord(SerializableMixin, TimestampMixin, db.Model):
record_type = db.Column(db.String(10), nullable=False)
name = db.Column(db.String(256), nullable=False) # FQDN
content = db.Column(db.Text)
+ ttl = db.Column(db.Integer)
+ priority = db.Column(db.Integer)
+ # Nullable on purpose: rows predating migration 092 do not know these
+ # provider attributes. Restore must preserve/hydrate unknowns, not invent
+ # a default that could change live DNS behavior.
+ proxied = db.Column(db.Boolean)
source = db.Column(db.String(40)) # zone|ddns|preset|wordpress|email
app_id = db.Column(db.Integer, db.ForeignKey('applications.id'), nullable=True)
diff --git a/backend/app/services/cron_service.py b/backend/app/services/cron_service.py
index 5d162726..f16e9d86 100644
--- a/backend/app/services/cron_service.py
+++ b/backend/app/services/cron_service.py
@@ -28,6 +28,26 @@ SHIM_PATH = os.path.join(
'serverkit_cron_run.py',
)
+_UNSET = object()
+
+
+def _auto_capture_cron(action):
+ """Best-effort local CRON checkpoint without burdening utility callers.
+
+ Several unit-level and bootstrap callers use CronService outside a Flask
+ application context. Restore points are database-backed, so those callers
+ must retain the pre-existing standalone service behaviour.
+ """
+ from flask import has_app_context
+
+ if not has_app_context():
+ return None
+ from app.services.restore_point_service import auto_capture, get_adapter
+
+ if get_adapter('cron') is None:
+ return None
+ return auto_capture('cron', 'cron', action)
+
class CronService:
"""Service for managing cron jobs and scheduled tasks."""
@@ -57,14 +77,22 @@ class CronService:
@classmethod
def _load_jobs_metadata(cls) -> Dict:
"""Load job metadata from file."""
+ try:
+ return cls._load_jobs_metadata_strict()
+ except (json.JSONDecodeError, IOError, ValueError):
+ return {'jobs': {}}
+
+ @classmethod
+ def _load_jobs_metadata_strict(cls) -> Dict:
+ """Load metadata without converting corruption into an empty schedule."""
cls._ensure_data_dir()
- if os.path.exists(JOBS_FILE):
- try:
- with open(JOBS_FILE, 'r') as f:
- return json.load(f)
- except (json.JSONDecodeError, IOError):
- pass
- return {'jobs': {}}
+ if not os.path.exists(JOBS_FILE):
+ return {'jobs': {}}
+ with open(JOBS_FILE, 'r') as handle:
+ data = json.load(handle)
+ if not isinstance(data, dict) or not isinstance(data.get('jobs'), dict):
+ raise ValueError('CRON metadata is malformed')
+ return data
@classmethod
def _save_jobs_metadata(cls, data: Dict):
@@ -319,6 +347,8 @@ class CronService:
if not cls._validate_command(command):
return {'success': False, 'error': 'Invalid command: must use absolute paths and cannot contain shell operators (;, &&, ||, |, `, $())'}
+ _auto_capture_cron('add_job')
+
# Generate job ID
job_id = f"job_{datetime.now().strftime('%Y%m%d%H%M%S')}"
@@ -367,6 +397,9 @@ class CronService:
job_data = metadata.get('jobs', {}).get(job_id)
+ if job_data is not None:
+ _auto_capture_cron('remove_job')
+
if cls.is_linux() and job_data:
current = cls._read_crontab()
if current is not None:
@@ -408,6 +441,7 @@ class CronService:
return {'success': False, 'error': 'Job not found'}
job_data = metadata['jobs'][job_id]
+ _auto_capture_cron('toggle_job')
if cls.is_linux():
current = cls._read_crontab()
@@ -527,6 +561,8 @@ class CronService:
if schedule and not cls._validate_schedule(schedule):
return {'success': False, 'error': 'Invalid cron schedule format'}
+ _auto_capture_cron('update_job')
+
# Update crontab on Linux if schedule or command changed
if cls.is_linux() and (new_schedule != old_schedule or new_command != old_command):
current = cls._read_crontab()
@@ -660,7 +696,8 @@ class CronService:
return job
@classmethod
- def set_tracking(cls, job_id: str, enabled: bool) -> Dict:
+ def set_tracking(cls, job_id: str, enabled: bool, *,
+ alert_on_failure=_UNSET) -> Dict:
"""Enable/disable run tracking for a job.
On Linux this rewrites the job's crontab line to add/remove the
@@ -673,6 +710,7 @@ class CronService:
job_data = metadata['jobs'][job_id]
enabled = bool(enabled)
was_tracked = bool(job_data.get('tracked', False))
+ _auto_capture_cron('set_tracking')
if cls.is_linux() and enabled != was_tracked:
schedule = job_data.get('schedule', '')
@@ -684,6 +722,8 @@ class CronService:
return err
job_data['tracked'] = enabled
+ if alert_on_failure is not _UNSET:
+ job_data['alert_on_failure'] = bool(alert_on_failure)
job_data['updated_at'] = datetime.now().isoformat()
cls._save_jobs_metadata(metadata)
@@ -732,13 +772,18 @@ class CronService:
delete uses `suspend_for_application` instead, which is reversible.
"""
metadata = cls._load_jobs_metadata()
+ targets = [
+ job_data for job_data in metadata.get('jobs', {}).values()
+ if cls._same_application(job_data.get('application_id'), application_id)
+ ]
+ if targets:
+ _auto_capture_cron('clear_application')
changed = 0
- for job_data in metadata.get('jobs', {}).values():
- if cls._same_application(job_data.get('application_id'), application_id):
- job_data['application_id'] = None
- job_data['suspended_by_app'] = False
- job_data['updated_at'] = datetime.now().isoformat()
- changed += 1
+ for job_data in targets:
+ job_data['application_id'] = None
+ job_data['suspended_by_app'] = False
+ job_data['updated_at'] = datetime.now().isoformat()
+ changed += 1
if changed:
cls._save_jobs_metadata(metadata)
return changed
@@ -765,8 +810,12 @@ class CronService:
if cls._same_application(job_data.get('application_id'), application_id)
and job_data.get('enabled')
]
- for job_id in targets:
- cls.toggle_job(job_id, False)
+ if targets:
+ _auto_capture_cron('suspend_for_application')
+ from app.services.restore_point_service import suppress_auto_capture
+ with suppress_auto_capture():
+ for job_id in targets:
+ cls.toggle_job(job_id, False)
if targets:
# Re-read: toggle_job persists on each call, so the copy above is
@@ -787,8 +836,12 @@ class CronService:
if cls._same_application(job_data.get('application_id'), application_id)
and job_data.get('suspended_by_app')
]
- for job_id in targets:
- cls.toggle_job(job_id, True)
+ if targets:
+ _auto_capture_cron('resume_for_application')
+ from app.services.restore_point_service import suppress_auto_capture
+ with suppress_auto_capture():
+ for job_id in targets:
+ cls.toggle_job(job_id, True)
if targets:
metadata = cls._load_jobs_metadata()
diff --git a/backend/app/services/dns/__init__.py b/backend/app/services/dns/__init__.py
index 0fdd69b8..c6ae14a1 100644
--- a/backend/app/services/dns/__init__.py
+++ b/backend/app/services/dns/__init__.py
@@ -7,16 +7,25 @@ provider lives in exactly one module.
"""
from app.services.dns.base import DnsCredential, DnsRecordSpec
from app.services.dns.cloudflare import CloudflareClient
+from app.services.dns.providers import (
+ DigitalOceanClient,
+ GoDaddyClient,
+ Route53Client,
+ get_record_client,
+)
-__all__ = ['DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'get_client']
+__all__ = [
+ 'DnsCredential', 'DnsRecordSpec', 'CloudflareClient', 'Route53Client',
+ 'DigitalOceanClient', 'GoDaddyClient', 'get_client', 'get_record_client',
+]
def get_client(credential: DnsCredential):
"""Return the API client for ``credential.provider``.
- Only Cloudflare is shared today (it was the duplicated path); Route53 /
- DigitalOcean / GoDaddy still live in ``DNSProviderService`` and can move
- behind this factory later without changing callers.
+ This legacy factory remains Cloudflare-only because DNS cutover currently
+ has Cloudflare-specific snapshot semantics. Record-management callers use
+ ``get_record_client`` for the four-provider contract.
"""
if credential.provider == 'cloudflare':
return CloudflareClient(credential)
diff --git a/backend/app/services/dns/base.py b/backend/app/services/dns/base.py
index b9e338b0..a9cbd273 100644
--- a/backend/app/services/dns/base.py
+++ b/backend/app/services/dns/base.py
@@ -53,7 +53,7 @@ class DnsRecordSpec:
content: str
ttl: int = 3600
priority: Optional[int] = None # MX / SRV
- proxied: bool = False # Cloudflare orange-cloud
+ proxied: Optional[bool] = False # Cloudflare orange-cloud; None = legacy unknown
@classmethod
def from_record(cls, record) -> 'DnsRecordSpec':
diff --git a/backend/app/services/dns/cloudflare.py b/backend/app/services/dns/cloudflare.py
index aced7f85..ce9ee400 100644
--- a/backend/app/services/dns/cloudflare.py
+++ b/backend/app/services/dns/cloudflare.py
@@ -43,6 +43,17 @@ def _first_error(data: dict) -> str:
return 'Unknown error'
+def _is_missing_record(data: dict) -> bool:
+ errors = data.get('errors') or []
+ for error in errors:
+ if error.get('code') in (81044, 81057):
+ return True
+ message = str(error.get('message') or '').lower()
+ if 'does not exist' in message or 'not found' in message:
+ return True
+ return False
+
+
class CloudflareClient:
"""Stateless wrapper around the Cloudflare v4 DNS API for one credential."""
@@ -183,7 +194,10 @@ class CloudflareClient:
f'{API_BASE}/zones/{zone_id}/dns_records?type={record_type}&name={name}',
headers=self._headers(), timeout=15,
)
- existing = (resp.json() or {}).get('result', []) or []
+ data = resp.json() or {}
+ if data.get('success') is False:
+ raise RuntimeError(_first_error(data))
+ existing = data.get('result', []) or []
if caa is not None:
existing = [
r for r in existing
@@ -235,11 +249,21 @@ class CloudflareClient:
else:
resp = requests.get(f'{base}?type={record_type}&name={name}',
headers=self._headers(), timeout=15)
- ids = [r['id'] for r in (resp.json() or {}).get('result', []) or []]
+ data = resp.json() or {}
+ if data.get('success') is False:
+ return {'success': False, 'error': _first_error(data)}
+ ids = [r['id'] for r in data.get('result', []) or []]
if not ids:
return {'success': True, 'message': 'Record not found (already deleted)'}
for rid in ids:
- requests.delete(f'{base}/{rid}', headers=self._headers(), timeout=15)
+ resp = requests.delete(
+ f'{base}/{rid}', headers=self._headers(), timeout=15,
+ )
+ data = resp.json() or {}
+ if data.get('success') is False:
+ if _is_missing_record(data):
+ continue
+ return {'success': False, 'error': _first_error(data)}
return {'success': True, 'message': 'Record deleted'}
except Exception as e:
return {'success': False, 'error': str(e)}
diff --git a/backend/app/services/dns/providers.py b/backend/app/services/dns/providers.py
new file mode 100644
index 00000000..12f6ac77
--- /dev/null
+++ b/backend/app/services/dns/providers.py
@@ -0,0 +1,482 @@
+"""Provider-agnostic record clients for Route53, DigitalOcean, and GoDaddy.
+
+Each client exposes the same record surface as :class:`CloudflareClient`:
+``list_records``, ``find_record_id``, ``upsert``, and ``delete``. The provider
+connection service and restore-point replay can therefore use the ownership
+door without knowing provider wire formats.
+"""
+import logging
+from typing import Optional
+
+import requests
+
+from app.services.dns.base import DnsCredential, DnsRecordSpec
+from app.services.dns.cloudflare import parse_caa_value
+
+logger = logging.getLogger(__name__)
+
+
+def _fqdn(value: str) -> str:
+ return (value or '').strip().lower().rstrip('.')
+
+
+def _relative_name(name: str, zone: str) -> str:
+ name = _fqdn(name)
+ zone = _fqdn(zone)
+ if not zone or name == zone:
+ return '@'
+ if name.endswith('.' + zone):
+ return name[:-len(zone) - 1]
+ return name or '@'
+
+
+def _absolute_name(name: str, zone: str) -> str:
+ name = (name or '@').strip().rstrip('.')
+ zone = _fqdn(zone)
+ if name in ('', '@'):
+ return zone
+ if _fqdn(name) == zone or _fqdn(name).endswith('.' + zone):
+ return _fqdn(name)
+ return f'{name}.{zone}'.lower()
+
+
+def _split_priority(spec: DnsRecordSpec):
+ content = spec.content
+ priority = spec.priority
+ if spec.record_type in ('MX', 'SRV') and priority is None:
+ head, _, rest = (content or '').strip().partition(' ')
+ if head.isdigit() and rest.strip():
+ priority, content = int(head), rest.strip()
+ return content, priority
+
+
+def _http_error(response, data, fallback='Provider request failed'):
+ if isinstance(data, dict):
+ return data.get('message') or data.get('error') or fallback
+ return f'HTTP {getattr(response, "status_code", "?")}: {fallback}'
+
+
+class Route53Client:
+ """Normalized Route53 RRset client."""
+
+ def __init__(self, credential: DnsCredential, client=None):
+ self.cred = credential
+ self._boto_client = client
+
+ def _client(self):
+ if self._boto_client is None:
+ try:
+ import boto3
+ except ImportError as exc:
+ raise RuntimeError(
+ 'boto3 is required for Route53 integration. '
+ 'Install with: pip install boto3'
+ ) from exc
+ self._boto_client = boto3.client(
+ 'route53',
+ aws_access_key_id=self.cred.token,
+ aws_secret_access_key=self.cred.secret,
+ )
+ return self._boto_client
+
+ @staticmethod
+ def _record_id(record_type: str, name: str) -> str:
+ # Route53 has no per-record id. Its mutation identity is the RRset key.
+ return f'{record_type.upper()}:{_fqdn(name)}'
+
+ @staticmethod
+ def _content(record_type, value):
+ value = str(value or '')
+ if record_type == 'TXT' and len(value) >= 2 and value[0] == value[-1] == '"':
+ return value[1:-1]
+ return value.rstrip('.') if record_type in ('CNAME', 'NS', 'PTR') else value
+
+ def list_records(self, zone_id: str) -> dict:
+ try:
+ out = []
+ kwargs = {'HostedZoneId': zone_id}
+ while True:
+ response = self._client().list_resource_record_sets(**kwargs)
+ for rrset in response.get('ResourceRecordSets', []):
+ record_type = rrset.get('Type')
+ name = _fqdn(rrset.get('Name'))
+ ttl = rrset.get('TTL')
+ values = rrset.get('ResourceRecords') or []
+ for value in values:
+ content = self._content(record_type, value.get('Value'))
+ priority = None
+ if record_type in ('MX', 'SRV'):
+ head, _, rest = content.partition(' ')
+ if head.isdigit() and rest:
+ priority, content = int(head), rest
+ out.append({
+ 'id': self._record_id(record_type, name),
+ 'type': record_type,
+ 'name': name,
+ 'content': content,
+ 'ttl': ttl,
+ 'priority': priority,
+ 'proxied': False,
+ })
+ if not response.get('IsTruncated'):
+ break
+ kwargs.update({
+ 'StartRecordName': response['NextRecordName'],
+ 'StartRecordType': response['NextRecordType'],
+ })
+ if response.get('NextRecordIdentifier'):
+ kwargs['StartRecordIdentifier'] = response['NextRecordIdentifier']
+ return {'success': True, 'records': out}
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def _find_rrset(self, zone_id, record_type, name):
+ fqdn = f'{_fqdn(name)}.'
+ response = self._client().list_resource_record_sets(
+ HostedZoneId=zone_id,
+ StartRecordName=fqdn,
+ StartRecordType=record_type,
+ MaxItems='1',
+ )
+ records = response.get('ResourceRecordSets', [])
+ return next((
+ item for item in records
+ if _fqdn(item.get('Name')) == _fqdn(name)
+ and item.get('Type') == record_type
+ ), None)
+
+ def find_record_id(self, zone_id: str, record_type: str, name: str,
+ caa: dict = None):
+ del caa # Route53 identity is the whole name+type RRset.
+ rrset = self._find_rrset(zone_id, record_type, name)
+ if rrset is None:
+ return None
+ return self._record_id(record_type, name)
+
+ @staticmethod
+ def _rrset(spec: DnsRecordSpec):
+ content, priority = _split_priority(spec)
+ if spec.record_type == 'TXT':
+ content = f'"{content}"'
+ elif spec.record_type == 'CAA':
+ caa = parse_caa_value(content)
+ content = f'{caa["flags"]} {caa["tag"]} "{caa["value"]}"'
+ elif priority is not None:
+ content = f'{priority} {content}'
+ return {
+ 'Name': f'{_fqdn(spec.name)}.',
+ 'Type': spec.record_type,
+ 'TTL': spec.ttl,
+ 'ResourceRecords': [{'Value': content}],
+ }
+
+ def upsert(self, zone_id: str, spec: DnsRecordSpec,
+ record_id: str = None) -> dict:
+ try:
+ self._client().change_resource_record_sets(
+ HostedZoneId=zone_id,
+ ChangeBatch={'Changes': [{
+ 'Action': 'UPSERT',
+ 'ResourceRecordSet': self._rrset(spec),
+ }]},
+ )
+ return {
+ 'success': True,
+ 'record_id': self._record_id(spec.record_type, spec.name),
+ 'message': f'{spec.record_type} record set for {spec.name}',
+ }
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def delete(self, zone_id: str, *, record_id: str = None,
+ record_type: str = None, name: str = None) -> dict:
+ try:
+ rrset = self._find_rrset(zone_id, record_type, name)
+ if rrset is None:
+ return {'success': True, 'message': 'Record not found (already deleted)'}
+ self._client().change_resource_record_sets(
+ HostedZoneId=zone_id,
+ ChangeBatch={'Changes': [{
+ 'Action': 'DELETE',
+ 'ResourceRecordSet': rrset,
+ }]},
+ )
+ return {'success': True, 'message': f'{record_type} record deleted for {name}'}
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+
+class DigitalOceanClient:
+ """Normalized DigitalOcean domain-record client."""
+
+ API_BASE = 'https://api.digitalocean.com/v2'
+
+ def __init__(self, credential: DnsCredential):
+ self.cred = credential
+
+ def _headers(self):
+ return {
+ 'Authorization': f'Bearer {self.cred.token or ""}',
+ 'Content-Type': 'application/json',
+ }
+
+ def _raw_records(self, zone_id, record_type=None):
+ params = '?per_page=200'
+ if record_type:
+ params += f'&type={record_type}'
+ response = requests.get(
+ f'{self.API_BASE}/domains/{zone_id}/records{params}',
+ headers=self._headers(), timeout=15,
+ )
+ data = response.json()
+ if response.status_code != 200:
+ raise RuntimeError(_http_error(response, data))
+ return data.get('domain_records', [])
+
+ @staticmethod
+ def _normalize(zone_id, record):
+ content = record.get('data', '')
+ priority = record.get('priority')
+ if record.get('type') == 'CAA':
+ content = f'{record.get("flags", 0)} {record.get("tag", "issue")} "{content}"'
+ return {
+ 'id': str(record.get('id')),
+ 'type': record.get('type'),
+ 'name': _absolute_name(record.get('name'), zone_id),
+ 'content': content,
+ 'ttl': record.get('ttl'),
+ 'priority': priority,
+ 'proxied': False,
+ }
+
+ def list_records(self, zone_id: str) -> dict:
+ try:
+ return {
+ 'success': True,
+ 'records': [self._normalize(zone_id, row) for row in self._raw_records(zone_id)],
+ }
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def find_record_id(self, zone_id: str, record_type: str, name: str,
+ caa: dict = None):
+ host = _relative_name(name, zone_id)
+ for row in self._raw_records(zone_id, record_type):
+ if row.get('name') != host:
+ continue
+ if caa is not None and (
+ row.get('tag') != caa['tag']
+ or str(row.get('data', '')).strip('"').rstrip('.').lower()
+ != caa['value'].rstrip('.').lower()
+ ):
+ continue
+ return str(row.get('id'))
+ return None
+
+ @staticmethod
+ def _payload(zone_id, spec):
+ content, priority = _split_priority(spec)
+ payload = {
+ 'type': spec.record_type,
+ 'name': _relative_name(spec.name, zone_id),
+ 'data': content,
+ 'ttl': spec.ttl,
+ }
+ if priority is not None:
+ payload['priority'] = priority
+ if spec.record_type == 'CAA':
+ caa = parse_caa_value(content)
+ payload.update(data=caa['value'], flags=caa['flags'], tag=caa['tag'])
+ return payload
+
+ def upsert(self, zone_id: str, spec: DnsRecordSpec,
+ record_id: str = None) -> dict:
+ try:
+ base = f'{self.API_BASE}/domains/{zone_id}/records'
+ if record_id is None:
+ caa = parse_caa_value(spec.content) if spec.record_type == 'CAA' else None
+ record_id = self.find_record_id(
+ zone_id, spec.record_type, spec.name, caa=caa,
+ )
+ payload = self._payload(zone_id, spec)
+ if record_id:
+ response = requests.put(
+ f'{base}/{record_id}', headers=self._headers(),
+ json=payload, timeout=15,
+ )
+ else:
+ response = requests.post(
+ base, headers=self._headers(), json=payload, timeout=15,
+ )
+ data = response.json()
+ if response.status_code not in (200, 201):
+ return {'success': False, 'error': _http_error(response, data)}
+ result_id = (data.get('domain_record') or {}).get('id') or record_id
+ return {
+ 'success': True,
+ 'record_id': str(result_id) if result_id is not None else None,
+ 'message': f'{spec.record_type} record set for {spec.name}',
+ }
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def delete(self, zone_id: str, *, record_id: str = None,
+ record_type: str = None, name: str = None) -> dict:
+ try:
+ ids = [record_id] if record_id else []
+ if not ids:
+ host = _relative_name(name, zone_id)
+ ids = [
+ str(row['id']) for row in self._raw_records(zone_id, record_type)
+ if row.get('name') == host
+ ]
+ if not ids:
+ return {'success': True, 'message': 'Record not found (already deleted)'}
+ for item_id in ids:
+ response = requests.delete(
+ f'{self.API_BASE}/domains/{zone_id}/records/{item_id}',
+ headers=self._headers(), timeout=15,
+ )
+ if response.status_code == 404:
+ continue
+ if response.status_code not in (200, 204):
+ try:
+ data = response.json()
+ except ValueError:
+ data = {}
+ return {'success': False, 'error': _http_error(response, data)}
+ return {'success': True, 'message': f'{record_type} record deleted for {name}'}
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+
+class GoDaddyClient:
+ """Normalized GoDaddy record-set client."""
+
+ API_BASE = 'https://api.godaddy.com/v1'
+
+ def __init__(self, credential: DnsCredential):
+ self.cred = credential
+
+ def _headers(self):
+ return {
+ 'Authorization': f'sso-key {self.cred.token or ""}:{self.cred.secret or ""}',
+ 'Content-Type': 'application/json',
+ }
+
+ @staticmethod
+ def _record_id(record_type, name):
+ return f'{record_type.upper()}:{name}'
+
+ def _raw_records(self, zone_id, record_type=None, name=None):
+ url = f'{self.API_BASE}/domains/{zone_id}/records'
+ if record_type:
+ url += f'/{record_type}'
+ if name is not None:
+ url += f'/{name}'
+ response = requests.get(url, headers=self._headers(), timeout=15)
+ data = response.json()
+ if response.status_code != 200:
+ raise RuntimeError(_http_error(response, data))
+ return data or []
+
+ @staticmethod
+ def _normalize(zone_id, row):
+ content = row.get('data', '')
+ priority = row.get('priority')
+ if row.get('type') == 'CAA':
+ content = f'{row.get("flags", 0)} {row.get("tag", "issue")} "{content}"'
+ return {
+ 'id': GoDaddyClient._record_id(row.get('type'), row.get('name')),
+ 'type': row.get('type'),
+ 'name': _absolute_name(row.get('name'), zone_id),
+ 'content': content,
+ 'ttl': row.get('ttl'),
+ 'priority': priority,
+ 'proxied': False,
+ }
+
+ def list_records(self, zone_id: str) -> dict:
+ try:
+ return {
+ 'success': True,
+ 'records': [self._normalize(zone_id, row) for row in self._raw_records(zone_id)],
+ }
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def find_record_id(self, zone_id: str, record_type: str, name: str,
+ caa: dict = None):
+ del caa # GoDaddy PUT addresses/replaces the whole name+type RRset.
+ host = _relative_name(name, zone_id)
+ rows = self._raw_records(zone_id, record_type, host)
+ return self._record_id(record_type, host) if rows else None
+
+ @staticmethod
+ def _payload(spec):
+ content, priority = _split_priority(spec)
+ row = {'data': content, 'ttl': spec.ttl}
+ if priority is not None:
+ row['priority'] = priority
+ if spec.record_type == 'CAA':
+ caa = parse_caa_value(content)
+ row.update(data=caa['value'], flags=caa['flags'], tag=caa['tag'])
+ return row
+
+ def upsert(self, zone_id: str, spec: DnsRecordSpec,
+ record_id: str = None) -> dict:
+ try:
+ host = _relative_name(spec.name, zone_id)
+ response = requests.put(
+ f'{self.API_BASE}/domains/{zone_id}/records/{spec.record_type}/{host}',
+ headers=self._headers(), json=[self._payload(spec)], timeout=15,
+ )
+ if response.status_code not in (200, 201, 204):
+ try:
+ data = response.json()
+ except ValueError:
+ data = {}
+ return {'success': False, 'error': _http_error(response, data)}
+ return {
+ 'success': True,
+ 'record_id': self._record_id(spec.record_type, host),
+ 'message': f'{spec.record_type} record set for {spec.name}',
+ }
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+ def delete(self, zone_id: str, *, record_id: str = None,
+ record_type: str = None, name: str = None) -> dict:
+ try:
+ host = _relative_name(name, zone_id)
+ response = requests.delete(
+ f'{self.API_BASE}/domains/{zone_id}/records/{record_type}/{host}',
+ headers=self._headers(), timeout=15,
+ )
+ if response.status_code in (200, 204, 404):
+ message = ('Record not found (already deleted)'
+ if response.status_code == 404
+ else f'{record_type} record deleted for {name}')
+ return {'success': True, 'message': message}
+ try:
+ data = response.json()
+ except ValueError:
+ data = {}
+ return {'success': False, 'error': _http_error(response, data)}
+ except Exception as exc:
+ return {'success': False, 'error': str(exc)}
+
+
+def get_record_client(credential: DnsCredential, *, route53_client=None):
+ """Build a normalized record client for every supported provider."""
+ provider = (credential.provider or '').lower()
+ if provider == 'cloudflare':
+ from app.services.dns.cloudflare import CloudflareClient
+ return CloudflareClient(credential)
+ if provider == 'route53':
+ return Route53Client(credential, client=route53_client)
+ if provider == 'digitalocean':
+ return DigitalOceanClient(credential)
+ if provider == 'godaddy':
+ return GoDaddyClient(credential)
+ raise ValueError(f'No DNS record client for provider: {credential.provider}')
diff --git a/backend/app/services/dns_change_service.py b/backend/app/services/dns_change_service.py
index 964cfb81..891a6f82 100644
--- a/backend/app/services/dns_change_service.py
+++ b/backend/app/services/dns_change_service.py
@@ -6,6 +6,7 @@ Recording happens at the single write choke point
connection is a complete, honest account of what the panel changed in the user's
zone — successes, foreign-record refusals, and failures alike.
"""
+import json
import logging
from app import db
@@ -19,7 +20,7 @@ class DnsChangeService:
@staticmethod
def record(*, provider, provider_zone_id, action, record_type=None, name=None,
content=None, provider_record_id=None, source=None, result='ok',
- error=None, config_id=None):
+ error=None, config_id=None, before=None):
"""Append a change to the log. On a real failure (``result == 'error'``) also
surface an admin-facing notice. Never raises — logging a change must not break
the write it describes."""
@@ -27,6 +28,8 @@ class DnsChangeService:
row = DnsChange(
provider=provider, provider_zone_id=provider_zone_id, action=action,
record_type=record_type, name=name, content=content,
+ before_json=(json.dumps(before, sort_keys=True, separators=(',', ':'))
+ if isinstance(before, (dict, list)) else before),
provider_record_id=provider_record_id, source=source,
result=result, error=error, dns_provider_config_id=config_id)
db.session.add(row)
diff --git a/backend/app/services/dns_ownership_service.py b/backend/app/services/dns_ownership_service.py
index 9833755f..b384883f 100644
--- a/backend/app/services/dns_ownership_service.py
+++ b/backend/app/services/dns_ownership_service.py
@@ -20,39 +20,127 @@ from app.models.managed_dns_record import ManagedDnsRecord
logger = logging.getLogger(__name__)
+_UNSET = object()
+LEGACY_DNS_CONFIG = 'legacy'
+
+
+def dns_scope_id(provider, config_id, provider_zone_id):
+ """Stable restore-point scope: provider:config-or-legacy:zone."""
+ config_key = LEGACY_DNS_CONFIG if config_id is None else str(config_id)
+ return f'{str(provider).lower()}:{config_key}:{provider_zone_id}'
+
+
+def parse_dns_scope_id(scope_id):
+ """Return ``(provider, config_id|None, provider_zone_id)``."""
+ try:
+ provider, config_key, provider_zone_id = str(scope_id).split(':', 2)
+ except ValueError as exc:
+ raise ValueError('DNS scope must be provider:config-or-legacy:zone') from exc
+ if not provider or not provider_zone_id:
+ raise ValueError('DNS scope must include provider and zone')
+ if config_key == LEGACY_DNS_CONFIG:
+ config_id = None
+ else:
+ try:
+ config_id = int(config_key)
+ except (TypeError, ValueError) as exc:
+ raise ValueError('DNS scope has an invalid provider configuration') from exc
+ return provider.lower(), config_id, provider_zone_id
+
class DnsOwnershipService:
+ @staticmethod
+ def scope_id(provider, config_id, provider_zone_id):
+ return dns_scope_id(provider, config_id, provider_zone_id)
+
+ @staticmethod
+ def _scope_query(provider_zone_id, *, provider=None, config_id=_UNSET):
+ query = ManagedDnsRecord.query.filter_by(
+ provider_zone_id=provider_zone_id,
+ )
+ if provider is not None:
+ query = query.filter_by(provider=str(provider).lower())
+ if config_id is not _UNSET:
+ if config_id is None:
+ query = query.filter(ManagedDnsRecord.dns_provider_config_id.is_(None))
+ else:
+ query = query.filter_by(dns_provider_config_id=config_id)
+ return query
+
# ── ledger reads ─────────────────────────────────────────────────────────
@staticmethod
- def _row(provider_zone_id, record_type, name):
- return ManagedDnsRecord.query.filter_by(
- provider_zone_id=provider_zone_id, record_type=record_type, name=name).first()
+ def _row(provider_zone_id, record_type, name, *, provider=None,
+ config_id=_UNSET):
+ """One owned RRset, scoped so identical provider zone ids cannot collide."""
+ normalized_type = str(record_type or '').upper()
+ normalized_name = str(name or '').lower().rstrip('.')
+ query = DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ ).filter_by(record_type=normalized_type)
+ return query.filter(
+ db.func.lower(db.func.rtrim(ManagedDnsRecord.name, '.'))
+ == normalized_name,
+ ).first()
@staticmethod
- def owns(provider_zone_id, *, provider_record_id=None, record_type=None, name=None):
+ def _row_by_id(provider_zone_id, provider_record_id, *, provider=None,
+ config_id=_UNSET):
+ return DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ ).filter_by(provider_record_id=provider_record_id).first()
+
+ @staticmethod
+ def record_payload(row):
+ """Complete managed DNS pre-image used by restore points/change rows."""
+ if row is None:
+ return None
+ return {
+ 'record_type': row.record_type,
+ 'name': row.name,
+ 'content': row.content,
+ 'ttl': row.ttl,
+ 'priority': row.priority,
+ 'proxied': row.proxied,
+ 'source': row.source,
+ 'app_id': row.app_id,
+ }
+
+ @staticmethod
+ def owns(provider_zone_id, *, provider_record_id=None, record_type=None,
+ name=None, provider=None, config_id=_UNSET):
"""Whether ServerKit created the matching record (by provider record id, or
by type+name)."""
- q = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id)
+ q = DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ )
if provider_record_id:
q = q.filter_by(provider_record_id=provider_record_id)
elif record_type and name:
- q = q.filter_by(record_type=record_type, name=name)
+ return DnsOwnershipService._row(
+ provider_zone_id, record_type, name,
+ provider=provider, config_id=config_id,
+ ) is not None
else:
return False
return q.first() is not None
@staticmethod
- def owned_keys(provider_zone_id):
+ def owned_keys(provider_zone_id, *, provider=None, config_id=_UNSET):
"""``(record_id set, (type, lower-name) set)`` for fast mirror classification."""
- rows = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id).all()
+ rows = DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ ).all()
ids = {r.provider_record_id for r in rows if r.provider_record_id}
- keys = {(r.record_type, (r.name or '').lower().rstrip('.')) for r in rows}
+ keys = {((r.record_type or '').upper(), (r.name or '').lower().rstrip('.'))
+ for r in rows}
return ids, keys
@staticmethod
- def list_for_zone(provider_zone_id):
- return ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id).all()
+ def list_for_zone(provider_zone_id, *, provider=None, config_id=_UNSET):
+ return DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ ).all()
@staticmethod
def list_all():
@@ -63,8 +151,15 @@ class DnsOwnershipService:
@staticmethod
def record_write(provider, provider_zone_id, record_type, name, *,
provider_record_id=None, content=None, source=None,
- app_id=None, config_id=None):
- row = DnsOwnershipService._row(provider_zone_id, record_type, name)
+ app_id=None, config_id=None, ttl=None, priority=None,
+ proxied=None):
+ provider = str(provider).lower()
+ record_type = str(record_type).upper()
+ name = str(name).lower().rstrip('.')
+ row = DnsOwnershipService._row(
+ provider_zone_id, record_type, name,
+ provider=provider, config_id=config_id,
+ )
if row is None:
row = ManagedDnsRecord(provider=provider, provider_zone_id=provider_zone_id,
record_type=record_type, name=name)
@@ -72,6 +167,9 @@ class DnsOwnershipService:
if provider_record_id:
row.provider_record_id = provider_record_id
row.content = content
+ row.ttl = ttl
+ row.priority = priority
+ row.proxied = proxied
if source:
row.source = source
if app_id is not None:
@@ -82,12 +180,20 @@ class DnsOwnershipService:
return row
@staticmethod
- def record_delete(provider_zone_id, *, record_type=None, name=None, provider_record_id=None):
- q = ManagedDnsRecord.query.filter_by(provider_zone_id=provider_zone_id)
+ def record_delete(provider_zone_id, *, record_type=None, name=None,
+ provider_record_id=None, provider=None,
+ config_id=_UNSET):
+ q = DnsOwnershipService._scope_query(
+ provider_zone_id, provider=provider, config_id=config_id,
+ )
if provider_record_id:
q = q.filter_by(provider_record_id=provider_record_id)
elif record_type and name:
- q = q.filter_by(record_type=record_type, name=name)
+ normalized_name = str(name).lower().rstrip('.')
+ q = q.filter_by(record_type=str(record_type).upper()).filter(
+ db.func.lower(db.func.rtrim(ManagedDnsRecord.name, '.'))
+ == normalized_name,
+ )
else:
return 0
n = q.delete()
@@ -107,13 +213,40 @@ class DnsOwnershipService:
"""
from app.services.dns.cloudflare import parse_caa_value
from app.services.dns_change_service import DnsChangeService
+ from app.services.restore_point_service import auto_capture
+
+ provider = str(provider).lower()
+ spec.record_type = str(spec.record_type).upper()
+ spec.name = str(spec.name).lower().rstrip('.')
+ if spec.record_type in ('MX', 'SRV') and spec.priority is None:
+ head, _, rest = str(spec.content or '').strip().partition(' ')
+ if head.isdigit() and rest.strip():
+ # Canonicalize once at the door so every provider and the
+ # ownership ledger see complete, replayable priority data.
+ spec.priority = int(head)
+ spec.content = rest.strip()
+
+ before_row = DnsOwnershipService._row(
+ provider_zone_id, spec.record_type, spec.name,
+ provider=provider, config_id=config_id,
+ )
+ before = DnsOwnershipService.record_payload(before_row)
record_id = known_record_id
if record_id is None:
caa = parse_caa_value(spec.content) if spec.record_type == 'CAA' else None
- existing = client.find_record_id(provider_zone_id, spec.record_type, spec.name, caa=caa)
+ existing = client.find_record_id(
+ provider_zone_id, spec.record_type, spec.name, caa=caa,
+ )
if existing:
- if DnsOwnershipService.owns(provider_zone_id, provider_record_id=existing):
+ owns_existing_id = DnsOwnershipService.owns(
+ provider_zone_id, provider_record_id=existing,
+ provider=provider, config_id=config_id,
+ )
+ owns_rrset_without_id = (
+ before_row is not None and not before_row.provider_record_id
+ )
+ if owns_existing_id or owns_rrset_without_id:
record_id = existing # ours — update in place
elif allow_foreign:
record_id = existing # explicit management — adopt it
@@ -125,22 +258,29 @@ class DnsOwnershipService:
DnsChangeService.record(
provider=provider, provider_zone_id=provider_zone_id, action='create',
record_type=spec.record_type, name=spec.name, content=spec.content,
- source=source, result='conflict', error=msg, config_id=config_id)
+ source=source, result='conflict', error=msg,
+ config_id=config_id, before=before)
return {'success': False, 'conflict': True, 'error': msg}
- action = 'update' if record_id else 'create'
+ action = 'update' if record_id or before_row is not None else 'create'
+ auto_capture(
+ 'dns', dns_scope_id(provider, config_id, provider_zone_id),
+ f'upsert {spec.record_type} {spec.name}',
+ )
res = client.upsert(provider_zone_id, spec, record_id=record_id)
if res.get('success'):
DnsOwnershipService.record_write(
provider, provider_zone_id, spec.record_type, spec.name,
provider_record_id=res.get('record_id'), content=spec.content,
- source=source, app_id=app_id, config_id=config_id)
+ source=source, app_id=app_id, config_id=config_id,
+ ttl=spec.ttl, priority=spec.priority, proxied=spec.proxied)
DnsChangeService.record(
provider=provider, provider_zone_id=provider_zone_id, action=action,
record_type=spec.record_type, name=spec.name, content=spec.content,
provider_record_id=res.get('record_id'), source=source,
result='ok' if res.get('success') else 'error',
- error=None if res.get('success') else res.get('error'), config_id=config_id)
+ error=None if res.get('success') else res.get('error'),
+ config_id=config_id, before=before)
return res
@staticmethod
@@ -149,20 +289,43 @@ class DnsOwnershipService:
"""Delete only a record ServerKit owns; never a foreign one. Clears our
ledger entry and logs the change on success."""
from app.services.dns_change_service import DnsChangeService
+ from app.services.restore_point_service import auto_capture
+
+ provider = str(provider).lower()
if provider_record_id:
- owned = DnsOwnershipService.owns(provider_zone_id, provider_record_id=provider_record_id)
+ owned_row = DnsOwnershipService._row_by_id(
+ provider_zone_id, provider_record_id,
+ provider=provider, config_id=config_id,
+ )
else:
- owned = DnsOwnershipService.owns(provider_zone_id, record_type=record_type, name=name)
- if not owned:
+ owned_row = DnsOwnershipService._row(
+ provider_zone_id, record_type, name,
+ provider=provider, config_id=config_id,
+ )
+ if owned_row is None:
return {'success': True, 'skipped': True,
'message': 'No ServerKit-owned record to delete.'}
+
+ before = DnsOwnershipService.record_payload(owned_row)
+ provider_record_id = provider_record_id or owned_row.provider_record_id
+ auto_capture(
+ 'dns', dns_scope_id(provider, config_id, provider_zone_id),
+ f'delete {record_type} {name}',
+ )
res = client.delete(provider_zone_id, record_id=provider_record_id,
record_type=record_type, name=name)
- DnsOwnershipService.record_delete(provider_zone_id, record_type=record_type,
- name=name, provider_record_id=provider_record_id)
+ # A failed provider delete must keep ownership. Otherwise a transient
+ # failure turns our still-live record into one ServerKit now sees as foreign.
+ if res.get('success'):
+ DnsOwnershipService.record_delete(
+ provider_zone_id, record_type=record_type, name=name,
+ provider_record_id=provider_record_id, provider=provider,
+ config_id=config_id,
+ )
DnsChangeService.record(
provider=provider, provider_zone_id=provider_zone_id, action='delete',
record_type=record_type, name=name, provider_record_id=provider_record_id,
source=source, result='ok' if res.get('success') else 'error',
- error=None if res.get('success') else res.get('error'), config_id=config_id)
+ error=None if res.get('success') else res.get('error'),
+ config_id=config_id, before=before)
return res
diff --git a/backend/app/services/dns_provider_service.py b/backend/app/services/dns_provider_service.py
index 38c74ff1..59e65f89 100644
--- a/backend/app/services/dns_provider_service.py
+++ b/backend/app/services/dns_provider_service.py
@@ -145,40 +145,22 @@ class DNSProviderService:
name: str, value: str, ttl: int = 3600,
proxied: bool = False, priority: int = None,
source: str = 'provider') -> Dict:
- """Create or update a DNS record. ``proxied``/``priority`` are honored by
- the Cloudflare path; other providers ignore them. ``source`` tags the write
- in the ownership ledger."""
+ """Create or update through the common client + ownership door."""
config = DNSProviderConfig.query.get(provider_id)
if not config:
return {'success': False, 'error': 'Provider not found'}
-
- if config.provider == 'cloudflare':
- return cls._cloudflare_set_record(config, zone_id, record_type, name, value, ttl,
- proxied=proxied, priority=priority, source=source)
- elif config.provider == 'route53':
- return cls._route53_set_record(config, zone_id, record_type, name, value, ttl)
- elif config.provider == 'digitalocean':
- return cls._digitalocean_set_record(config, zone_id, record_type, name, value, ttl)
- elif config.provider == 'godaddy':
- return cls._godaddy_set_record(config, zone_id, record_type, name, value, ttl)
- return {'success': False, 'error': 'Unknown provider'}
+ return cls._guarded_set_record(
+ config, zone_id, record_type, name, value, ttl,
+ proxied=proxied, priority=priority, source=source,
+ )
@classmethod
def delete_record(cls, provider_id: int, zone_id: str, record_type: str, name: str) -> Dict:
- """Delete a DNS record."""
+ """Delete through the common client + ownership door."""
config = DNSProviderConfig.query.get(provider_id)
if not config:
return {'success': False, 'error': 'Provider not found'}
-
- if config.provider == 'cloudflare':
- return cls._cloudflare_delete_record(config, zone_id, record_type, name)
- elif config.provider == 'route53':
- return cls._route53_delete_record(config, zone_id, record_type, name)
- elif config.provider == 'digitalocean':
- return cls._digitalocean_delete_record(config, zone_id, record_type, name)
- elif config.provider == 'godaddy':
- return cls._godaddy_delete_record(config, zone_id, record_type, name)
- return {'success': False, 'error': 'Unknown provider'}
+ return cls._guarded_delete_record(config, zone_id, record_type, name)
@classmethod
def deploy_email_records(cls, provider_id: int, zone_id: str, domain: str,
@@ -270,6 +252,58 @@ class DNSProviderService:
from app.services.dns.cloudflare import parse_caa_value as _parse
return _parse(value)
+ @classmethod
+ def record_client(cls, config: DNSProviderConfig):
+ """Build the normalized record client for a connected provider."""
+ from app.services.dns import get_record_client
+ from app.services.dns.base import DnsCredential
+ return get_record_client(DnsCredential.from_provider_config(config))
+
+ @classmethod
+ def _guarded_set_record(cls, config, zone_id, record_type, name, value,
+ ttl=3600, *, proxied=False, priority=None,
+ source='provider'):
+ from app.services.dns.base import DnsRecordSpec
+ from app.services.dns_ownership_service import DnsOwnershipService
+
+ spec = DnsRecordSpec(
+ record_type=record_type, name=name, content=value, ttl=ttl,
+ priority=priority, proxied=proxied,
+ )
+ try:
+ result = DnsOwnershipService.guarded_upsert(
+ cls.record_client(config), provider=config.provider,
+ provider_zone_id=zone_id, spec=spec, source=source,
+ config_id=config.id, allow_foreign=False,
+ )
+ except (TypeError, ValueError, RuntimeError) as exc:
+ return {'success': False, 'error': str(exc)}
+
+ if result.get('success'):
+ return {
+ 'success': True,
+ 'message': result.get(
+ 'message', f'{record_type} record set for {name}',
+ ),
+ }
+ output = {'success': False, 'error': result.get('error', 'Unknown error')}
+ if result.get('conflict'):
+ output['conflict'] = True
+ return output
+
+ @classmethod
+ def _guarded_delete_record(cls, config, zone_id, record_type, name,
+ *, source='provider'):
+ from app.services.dns_ownership_service import DnsOwnershipService
+ try:
+ return DnsOwnershipService.guarded_delete(
+ cls.record_client(config), provider=config.provider,
+ provider_zone_id=zone_id, record_type=record_type, name=name,
+ source=source, config_id=config.id,
+ )
+ except (TypeError, ValueError, RuntimeError) as exc:
+ return {'success': False, 'error': str(exc)}
+
@classmethod
def ensure_caa_record(cls, domain: str, ca: str = 'letsencrypt.org') -> Dict:
"""Ensure a CAA record authorizing ``ca`` (default Let's Encrypt) exists at
@@ -332,34 +366,17 @@ class DNSProviderService:
record_type: str, name: str, value: str, ttl: int,
proxied: bool = False, priority: int = None,
source: str = 'provider') -> Dict:
- """Create or update a Cloudflare DNS record (idempotent upsert by name),
- gated by the ownership guard so an automatic write never clobbers a record
- the user created themselves."""
- from app.services.dns.base import DnsRecordSpec
- from app.services.dns_ownership_service import DnsOwnershipService
- spec = DnsRecordSpec(record_type=record_type, name=name, content=value,
- ttl=ttl, priority=priority, proxied=proxied)
- res = DnsOwnershipService.guarded_upsert(
- cls._cloudflare_client(config), provider='cloudflare', provider_zone_id=zone_id,
- spec=spec, source=source, config_id=config.id, allow_foreign=False)
- # Preserve the historical {success, message|error} contract callers expect.
- if res.get('success'):
- return {'success': True,
- 'message': res.get('message', f'{record_type} record set for {name}')}
- out = {'success': False, 'error': res.get('error', 'Unknown error')}
- if res.get('conflict'):
- out['conflict'] = True
- return out
+ return cls._guarded_set_record(
+ config, zone_id, record_type, name, value, ttl,
+ proxied=proxied, priority=priority, source=source,
+ )
@classmethod
def _cloudflare_delete_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str) -> Dict:
"""Delete a Cloudflare DNS record ServerKit owns (by type+name); a foreign
record with that name is left untouched."""
- from app.services.dns_ownership_service import DnsOwnershipService
- return DnsOwnershipService.guarded_delete(
- cls._cloudflare_client(config), provider_zone_id=zone_id,
- record_type=record_type, name=name, config_id=config.id)
+ return cls._guarded_delete_record(config, zone_id, record_type, name)
@staticmethod
def _host_relative_to_zone(name: str, zone: str) -> str:
@@ -425,71 +442,14 @@ class DNSProviderService:
@classmethod
def _route53_set_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str, value: str, ttl: int) -> Dict:
- """Create or update a Route53 DNS record."""
- try:
- client = cls._get_route53_client(config)
- # Ensure name ends with a dot for Route53
- fqdn = name if name.endswith('.') else f'{name}.'
-
- resource_record = {'Value': value}
- if record_type == 'TXT':
- # TXT records need to be quoted
- resource_record = {'Value': f'"{value}"'}
- elif record_type == 'MX':
- resource_record = {'Value': value}
-
- client.change_resource_record_sets(
- HostedZoneId=zone_id,
- ChangeBatch={
- 'Changes': [{
- 'Action': 'UPSERT',
- 'ResourceRecordSet': {
- 'Name': fqdn,
- 'Type': record_type,
- 'TTL': ttl,
- 'ResourceRecords': [resource_record],
- }
- }]
- }
- )
- return {'success': True, 'message': f'{record_type} record set for {name}'}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_set_record(
+ config, zone_id, record_type, name, value, ttl,
+ )
@classmethod
def _route53_delete_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str) -> Dict:
- """Delete a Route53 DNS record."""
- try:
- client = cls._get_route53_client(config)
- fqdn = name if name.endswith('.') else f'{name}.'
-
- # Get current record to know its value (required for DELETE)
- resp = client.list_resource_record_sets(
- HostedZoneId=zone_id,
- StartRecordName=fqdn,
- StartRecordType=record_type,
- MaxItems='1',
- )
- records = resp.get('ResourceRecordSets', [])
- matching = [r for r in records if r['Name'] == fqdn and r['Type'] == record_type]
-
- if not matching:
- return {'success': True, 'message': 'Record not found (already deleted)'}
-
- record = matching[0]
- client.change_resource_record_sets(
- HostedZoneId=zone_id,
- ChangeBatch={
- 'Changes': [{
- 'Action': 'DELETE',
- 'ResourceRecordSet': record,
- }]
- }
- )
- return {'success': True, 'message': f'{record_type} record deleted for {name}'}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_delete_record(config, zone_id, record_type, name)
# ── DigitalOcean Implementation ──
@@ -538,75 +498,14 @@ class DNSProviderService:
@classmethod
def _digitalocean_set_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str, value: str, ttl: int) -> Dict:
- """Create or update a DigitalOcean DNS record (zone_id is the domain)."""
- try:
- headers = cls._digitalocean_headers(config)
- base = f'https://api.digitalocean.com/v2/domains/{zone_id}/records'
- host = cls._host_relative_to_zone(name, zone_id)
-
- payload = {'type': record_type, 'name': host, 'data': value, 'ttl': ttl}
- if record_type == 'MX':
- # Input is "<priority> <target>"; split into priority + data.
- parts = value.split(None, 1)
- if len(parts) == 2 and parts[0].isdigit():
- payload['priority'] = int(parts[0])
- payload['data'] = parts[1]
- elif record_type == 'CAA':
- # DigitalOcean wants flags/tag as separate fields, data = CA value.
- caa = cls.parse_caa_value(value)
- payload['flags'] = caa['flags']
- payload['tag'] = caa['tag']
- payload['data'] = caa['value']
-
- # Find an existing record of the same type/host to update.
- resp = requests.get(
- f'{base}?type={record_type}&per_page=200',
- headers=headers, timeout=15,
- )
- data = resp.json()
- existing = [r for r in data.get('domain_records', []) if r.get('name') == host]
-
- if existing:
- record_id = existing[0]['id']
- resp = requests.put(
- f'{base}/{record_id}',
- headers=headers, json=payload, timeout=15,
- )
- else:
- resp = requests.post(base, headers=headers, json=payload, timeout=15)
-
- if resp.status_code in (200, 201):
- return {'success': True, 'message': f'{record_type} record set for {name}'}
- data = resp.json()
- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_set_record(
+ config, zone_id, record_type, name, value, ttl,
+ )
@classmethod
def _digitalocean_delete_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str) -> Dict:
- """Delete a DigitalOcean DNS record (zone_id is the domain)."""
- try:
- headers = cls._digitalocean_headers(config)
- base = f'https://api.digitalocean.com/v2/domains/{zone_id}/records'
- host = cls._host_relative_to_zone(name, zone_id)
-
- resp = requests.get(
- f'{base}?type={record_type}&per_page=200',
- headers=headers, timeout=15,
- )
- data = resp.json()
- existing = [r for r in data.get('domain_records', []) if r.get('name') == host]
-
- if not existing:
- return {'success': True, 'message': 'Record not found (already deleted)'}
-
- for record in existing:
- requests.delete(f'{base}/{record["id"]}', headers=headers, timeout=15)
-
- return {'success': True, 'message': f'{record_type} record deleted for {name}'}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_delete_record(config, zone_id, record_type, name)
# ── GoDaddy Implementation ──
@@ -656,43 +555,11 @@ class DNSProviderService:
@classmethod
def _godaddy_set_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str, value: str, ttl: int) -> Dict:
- """Create or update a GoDaddy DNS record (record-typed PUT, zone_id is the domain)."""
- try:
- headers = cls._godaddy_headers(config)
- host = cls._host_relative_to_zone(name, zone_id)
- url = f'https://api.godaddy.com/v1/domains/{zone_id}/records/{record_type}/{host}'
-
- record = {'data': value, 'ttl': ttl}
- if record_type == 'MX':
- # Input is "<priority> <target>"; GoDaddy wants priority + data.
- parts = value.split(None, 1)
- if len(parts) == 2 and parts[0].isdigit():
- record['priority'] = int(parts[0])
- record['data'] = parts[1]
-
- resp = requests.put(url, headers=headers, json=[record], timeout=15)
- if resp.status_code in (200, 201):
- return {'success': True, 'message': f'{record_type} record set for {name}'}
- data = resp.json()
- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_set_record(
+ config, zone_id, record_type, name, value, ttl,
+ )
@classmethod
def _godaddy_delete_record(cls, config: DNSProviderConfig, zone_id: str,
record_type: str, name: str) -> Dict:
- """Delete a GoDaddy DNS record (record-typed DELETE, zone_id is the domain)."""
- try:
- headers = cls._godaddy_headers(config)
- host = cls._host_relative_to_zone(name, zone_id)
- url = f'https://api.godaddy.com/v1/domains/{zone_id}/records/{record_type}/{host}'
-
- resp = requests.delete(url, headers=headers, timeout=15)
- if resp.status_code in (200, 204):
- return {'success': True, 'message': f'{record_type} record deleted for {name}'}
- if resp.status_code == 404:
- return {'success': True, 'message': 'Record not found (already deleted)'}
- data = resp.json()
- return {'success': False, 'error': data.get('message', f'HTTP {resp.status_code}')}
- except Exception as e:
- return {'success': False, 'error': str(e)}
+ return cls._guarded_delete_record(config, zone_id, record_type, name)
diff --git a/backend/app/services/dns_zone_service.py b/backend/app/services/dns_zone_service.py
index c2eeb1a0..03cbbc04 100644
--- a/backend/app/services/dns_zone_service.py
+++ b/backend/app/services/dns_zone_service.py
@@ -289,7 +289,16 @@ class DNSZoneService:
if not res.get('success'):
return res
- owned_ids, owned_keys = DnsOwnershipService.owned_keys(zone.provider_zone_id)
+ owned_ids, owned_keys = DnsOwnershipService.owned_keys(
+ zone.provider_zone_id, provider=zone.provider,
+ config_id=zone.dns_provider_config_id,
+ )
+ if zone.dns_provider_config_id is not None:
+ legacy_ids, legacy_keys = DnsOwnershipService.owned_keys(
+ zone.provider_zone_id, provider=zone.provider, config_id=None,
+ )
+ owned_ids |= legacy_ids
+ owned_keys |= legacy_keys
records = []
for r in res['records']:
owned = (r['id'] in owned_ids) or \
@@ -326,7 +335,14 @@ class DNSZoneService:
res = CloudflareClient(DnsCredential.from_provider_config(config)).list_records(provider_zone_id)
if not res.get('success'):
return res
- owned_ids, owned_keys = DnsOwnershipService.owned_keys(provider_zone_id)
+ owned_ids, owned_keys = DnsOwnershipService.owned_keys(
+ provider_zone_id, provider=config.provider, config_id=config.id,
+ )
+ legacy_ids, legacy_keys = DnsOwnershipService.owned_keys(
+ provider_zone_id, provider=config.provider, config_id=None,
+ )
+ owned_ids |= legacy_ids
+ owned_keys |= legacy_keys
records = []
for r in res['records']:
owned = (r['id'] in owned_ids) or \
diff --git a/backend/app/services/env_service.py b/backend/app/services/env_service.py
index b7bdfebe..459007c0 100644
--- a/backend/app/services/env_service.py
+++ b/backend/app/services/env_service.py
@@ -7,6 +7,7 @@ including encryption, history tracking, and .env file operations.
import logging
import re
+import uuid
from app import db
from app.models import Application, EnvironmentVariable, EnvironmentVariableHistory
@@ -17,6 +18,20 @@ logger = logging.getLogger(__name__)
_UNSET = object()
+def _new_batch_id():
+ """Return the shared ledger id for one multi-variable operation."""
+ return str(uuid.uuid4())
+
+
+def _auto_capture(application_id, action, user_id):
+ """Best-effort checkpoint immediately before an env mutation."""
+ from app.services.restore_point_service import auto_capture
+
+ return auto_capture(
+ 'env', str(application_id), action, actor=user_id,
+ )
+
+
class EnvService:
"""Service for managing application environment variables."""
@@ -112,7 +127,9 @@ class EnvService:
return ''
@staticmethod
- def set_env_reference(application_id, key, reference, user_id=None, target_service=_UNSET):
+ def set_env_reference(application_id, key, reference, user_id=None,
+ target_service=_UNSET, description=_UNSET,
+ batch_id=None):
"""Create/update a variable that resolves from a reference (manifest).
``reference`` is a dict e.g. {'kind':'secret','secret':'name'} or
@@ -128,12 +145,20 @@ class EnvService:
norm_target = None if target_service in ('', _UNSET) else target_service
existing = EnvService.get_env_var(application_id, key)
+ _auto_capture(application_id, 'env.set_env_reference', user_id)
if existing:
+ old_value = '<reference>' if existing.get_reference() else existing.value
existing.set_reference(reference)
existing.is_secret = True
existing.value = '' # clear any stored literal
if target_service is not _UNSET:
existing.target_service = norm_target
+ if description is not _UNSET:
+ existing.description = description
+ EnvironmentVariableHistory.record_change(
+ existing, 'updated', old_value=old_value,
+ new_value='<reference>', user_id=user_id, batch_id=batch_id,
+ )
db.session.commit()
return existing, False, None
@@ -141,12 +166,16 @@ class EnvService:
application_id=application_id, key=key, is_secret=True,
target_service=norm_target, created_by=user_id,
)
+ if description is not _UNSET:
+ env_var.description = description
env_var.set_reference(reference)
env_var.value = ''
db.session.add(env_var)
db.session.flush()
- EnvironmentVariableHistory.record_change(env_var, 'created', new_value='<reference>',
- user_id=user_id)
+ EnvironmentVariableHistory.record_change(
+ env_var, 'created', new_value='<reference>', user_id=user_id,
+ batch_id=batch_id,
+ )
db.session.commit()
return env_var, True, None
@@ -214,7 +243,7 @@ class EnvService:
@staticmethod
def set_env_var(application_id, key, value, is_secret=False, description=None,
- user_id=None, target_service=_UNSET):
+ user_id=None, target_service=_UNSET, batch_id=None):
"""
Set an environment variable (create or update).
Returns (env_var, created, error)
@@ -237,10 +266,15 @@ class EnvService:
# Check if key already exists
existing = EnvService.get_env_var(application_id, key)
+ _auto_capture(application_id, 'env.set_env_var', user_id)
if existing:
# Update existing
- old_value = existing.value
+ old_value = '<reference>' if existing.get_reference() else existing.value
+ # A literal write intentionally replaces a manifest reference.
+ # Restore code skips masked literals before reaching this door, so
+ # a redaction sentinel can never accidentally clear a reference.
+ existing.set_reference(None)
existing.value = value
existing.is_secret = is_secret
if description is not None:
@@ -250,7 +284,8 @@ class EnvService:
# Record history
EnvironmentVariableHistory.record_change(
- existing, 'updated', old_value=old_value, new_value=value, user_id=user_id
+ existing, 'updated', old_value=old_value, new_value=value,
+ user_id=user_id, batch_id=batch_id,
)
db.session.commit()
@@ -272,25 +307,67 @@ class EnvService:
# Record history
EnvironmentVariableHistory.record_change(
- env_var, 'created', new_value=value, user_id=user_id
+ env_var, 'created', new_value=value, user_id=user_id,
+ batch_id=batch_id,
)
db.session.commit()
return env_var, True, None
@staticmethod
- def delete_env_var(application_id, key, user_id=None):
+ def update_env_var(application_id, key, *, value=_UNSET,
+ is_secret=_UNSET, description=_UNSET,
+ target_service=_UNSET, user_id=None, batch_id=None):
+ """Update only supplied fields on an existing environment variable.
+
+ This is the service-layer door used by the PUT controller. Keeping
+ partial-update semantics here prevents API code from mutating ORM rows
+ directly and ensures the restore-point hook cannot be bypassed.
+ """
+ existing = EnvService.get_env_var(application_id, key)
+ if not existing:
+ return None, 'Environment variable not found'
+
+ if all(value is _UNSET for value in (
+ value, is_secret, description, target_service)):
+ return existing, None
+
+ _auto_capture(application_id, 'env.update_env_var', user_id)
+
+ old_value = '<reference>' if existing.get_reference() else existing.value
+ if value is not _UNSET:
+ existing.set_reference(None)
+ existing.value = value
+ if is_secret is not _UNSET:
+ existing.is_secret = bool(is_secret)
+ if description is not _UNSET:
+ existing.description = description
+ if target_service is not _UNSET:
+ existing.target_service = target_service or None
+
+ new_value = '<reference>' if existing.get_reference() else existing.value
+ EnvironmentVariableHistory.record_change(
+ existing, 'updated', old_value=old_value, new_value=new_value,
+ user_id=user_id, batch_id=batch_id,
+ )
+ db.session.commit()
+ return existing, None
+
+ @staticmethod
+ def delete_env_var(application_id, key, user_id=None, batch_id=None):
"""Delete an environment variable. Returns (success, error)."""
env_var = EnvService.get_env_var(application_id, key)
if not env_var:
return False, "Environment variable not found"
- old_value = env_var.value
+ _auto_capture(application_id, 'env.delete_env_var', user_id)
+ old_value = '<reference>' if env_var.get_reference() else env_var.value
# Record history before deletion
EnvironmentVariableHistory.record_change(
- env_var, 'deleted', old_value=old_value, user_id=user_id
+ env_var, 'deleted', old_value=old_value, user_id=user_id,
+ batch_id=batch_id,
)
db.session.delete(env_var)
@@ -299,18 +376,22 @@ class EnvService:
return True, None
@staticmethod
- def delete_env_var_by_id(env_var_id, user_id=None):
+ def delete_env_var_by_id(env_var_id, user_id=None, batch_id=None):
"""Delete an environment variable by ID. Returns (success, error)."""
env_var = EnvironmentVariable.query.get(env_var_id)
if not env_var:
return False, "Environment variable not found"
- old_value = env_var.value
+ _auto_capture(
+ env_var.application_id, 'env.delete_env_var_by_id', user_id,
+ )
+ old_value = '<reference>' if env_var.get_reference() else env_var.value
# Record history before deletion
EnvironmentVariableHistory.record_change(
- env_var, 'deleted', old_value=old_value, user_id=user_id
+ env_var, 'deleted', old_value=old_value, user_id=user_id,
+ batch_id=batch_id,
)
db.session.delete(env_var)
@@ -319,7 +400,8 @@ class EnvService:
return True, None
@staticmethod
- def bulk_set_env_vars(application_id, env_vars_dict, user_id=None):
+ def bulk_set_env_vars(application_id, env_vars_dict, user_id=None,
+ batch_id=None):
"""
Set multiple environment variables at once.
env_vars_dict: {key: value} or {key: {value, is_secret, description}}
@@ -327,25 +409,34 @@ class EnvService:
"""
count = 0
errors = []
+ batch_id = batch_id or _new_batch_id()
+
+ _auto_capture(application_id, 'env.bulk_set_env_vars', user_id)
+ from app.services.restore_point_service import suppress_auto_capture
+
+ with suppress_auto_capture():
+ for key, val in env_vars_dict.items():
+ if isinstance(val, dict):
+ value = val.get('value', '')
+ is_secret = val.get('is_secret', False)
+ description = val.get('description')
+ target_service = val.get('target_service', _UNSET)
+ else:
+ value = val
+ is_secret = False
+ description = None
+ target_service = _UNSET
+
+ env_var, created, error = EnvService.set_env_var(
+ application_id, key, value, is_secret, description,
+ user_id, target_service=target_service,
+ batch_id=batch_id,
+ )
- for key, val in env_vars_dict.items():
- if isinstance(val, dict):
- value = val.get('value', '')
- is_secret = val.get('is_secret', False)
- description = val.get('description')
- else:
- value = val
- is_secret = False
- description = None
-
- env_var, created, error = EnvService.set_env_var(
- application_id, key, value, is_secret, description, user_id
- )
-
- if error:
- errors.append(f"{key}: {error}")
- else:
- count += 1
+ if error:
+ errors.append(f"{key}: {error}")
+ else:
+ count += 1
return count, errors
@@ -471,16 +562,22 @@ class EnvService:
return {ev.key: ev.value for ev in env_vars}
@staticmethod
- def clear_all(application_id, user_id=None):
+ def clear_all(application_id, user_id=None, batch_id=None):
"""Delete all environment variables for an application."""
env_vars = EnvironmentVariable.query.filter_by(
application_id=application_id
).all()
+ if env_vars:
+ _auto_capture(application_id, 'env.clear_all', user_id)
+ batch_id = batch_id or _new_batch_id()
+
count = 0
for ev in env_vars:
+ old_value = '<reference>' if ev.get_reference() else ev.value
EnvironmentVariableHistory.record_change(
- ev, 'deleted', old_value=ev.value, user_id=user_id
+ ev, 'deleted', old_value=old_value, user_id=user_id,
+ batch_id=batch_id,
)
db.session.delete(ev)
count += 1
diff --git a/backend/app/services/firewall_service.py b/backend/app/services/firewall_service.py
index bf2187d0..5cb0f8cd 100644
--- a/backend/app/services/firewall_service.py
+++ b/backend/app/services/firewall_service.py
@@ -18,6 +18,24 @@ from app.utils.system import (
class FirewallService:
"""Service for managing firewall (firewalld or ufw)."""
+ @classmethod
+ def _checkpoint(cls, action: str, detail: str = ''):
+ """Best-effort checkpoint immediately before an accepted mutation."""
+ from flask import has_app_context
+
+ if not has_app_context():
+ return None
+ from app.services.restore_point_service import auto_capture, get_adapter
+
+ if get_adapter('firewall') is None:
+ return None
+
+ suffix = f' {detail}' if detail else ''
+ return auto_capture(
+ 'firewall', 'firewall', action,
+ label=f'before firewall.{action}{suffix}',
+ )
+
@classmethod
def get_status(cls) -> Dict:
"""Get firewall status and detect which firewall is in use."""
@@ -163,18 +181,28 @@ class FirewallService:
return sorted(set(ports)) or None
@classmethod
- def _ufw_default_incoming_allow(cls) -> bool:
- """True when ufw's default inbound policy is ACCEPT (no lockout risk)."""
+ def _ufw_default_incoming_policy(cls) -> Optional[bool]:
+ """Observed UFW inbound policy, or ``None`` when it cannot be read."""
try:
with open('/etc/default/ufw', 'r') as handle:
for line in handle:
match = re.match(r'^\s*DEFAULT_INPUT_POLICY\s*=\s*"?(\w+)"?',
line)
if match:
- return match.group(1).upper() == 'ACCEPT'
+ policy = match.group(1).upper()
+ if policy == 'ACCEPT':
+ return True
+ if policy in ('DROP', 'REJECT', 'DENY'):
+ return False
+ return None
except Exception:
pass
- return False
+ return None
+
+ @classmethod
+ def _ufw_default_incoming_allow(cls) -> bool:
+ """True only when UFW's observed inbound policy is ACCEPT."""
+ return cls._ufw_default_incoming_policy() is True
@classmethod
def _ufw_allowed_ports(cls) -> set:
@@ -294,6 +322,7 @@ class FirewallService:
'override': 'Send force=true to enable anyway.',
}
+ cls._checkpoint('enable', firewall)
if firewall == 'firewalld':
return cls._enable_firewalld()
return cls._enable_ufw()
@@ -329,8 +358,10 @@ class FirewallService:
firewall = status['active_firewall']
if firewall == 'firewalld':
+ cls._checkpoint('disable', firewall)
return cls._disable_firewalld()
elif firewall == 'ufw':
+ cls._checkpoint('disable', firewall)
return cls._disable_ufw()
else:
return {'success': False, 'error': 'No firewall detected'}
@@ -460,38 +491,72 @@ class FirewallService:
status = cls.get_status()
firewall = status['active_firewall']
+ error = cls._validate_rule_request(rule_type, kwargs)
+ if error:
+ return {'success': False, 'error': error}
+
if firewall == 'firewalld':
+ cls._checkpoint('add_rule', cls._rule_label(rule_type, kwargs))
+ kwargs['_offline'] = status.get('firewalld', {}).get('running') is False
return cls._add_firewalld_rule(rule_type, **kwargs)
elif firewall == 'ufw':
+ cls._checkpoint('add_rule', cls._rule_label(rule_type, kwargs))
return cls._add_ufw_rule(rule_type, **kwargs)
else:
return {'success': False, 'error': 'No firewall detected'}
+ @staticmethod
+ def _rule_label(rule_type: str, values: Dict) -> str:
+ target = (values.get('port') or values.get('service') or
+ values.get('ip') or values.get('rule') or '')
+ return f'{rule_type} {target}'.strip()
+
+ @staticmethod
+ def _validate_rule_request(rule_type: str, values: Dict,
+ *, removing: bool = False) -> Optional[str]:
+ if removing and values.get('number') is not None:
+ return None
+ required = {
+ 'port': ('port', 'Port number required'),
+ 'service': ('service', 'Service name required'),
+ 'block_ip': ('ip', 'IP address required'),
+ 'allow_ip': ('ip', 'IP address required'),
+ 'rich': ('rule', 'Rich rule required'),
+ }
+ entry = required.get(rule_type)
+ if entry is None:
+ return f'Unknown rule type: {rule_type}'
+ field, message = entry
+ return None if values.get(field) not in (None, '') else message
+
@classmethod
def _add_firewalld_rule(cls, rule_type: str, **kwargs) -> Dict:
"""Add a firewalld rule."""
try:
permanent = kwargs.get('permanent', True)
- perm_flag = ['--permanent'] if permanent else []
+ offline = bool(kwargs.get('_offline'))
+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'
+ perm_flag = ['--permanent'] if permanent and not offline else []
+ zone_flag = [f'--zone={kwargs["zone"]}'] if kwargs.get('zone') else []
if rule_type == 'service':
service = kwargs.get('service')
if not service:
return {'success': False, 'error': 'Service name required'}
- cmd = ['firewall-cmd'] + perm_flag + [f'--add-service={service}']
+ cmd = [command] + perm_flag + zone_flag + [f'--add-service={service}']
elif rule_type == 'port':
port = kwargs.get('port')
protocol = kwargs.get('protocol', 'tcp')
if not port:
return {'success': False, 'error': 'Port number required'}
- cmd = ['firewall-cmd'] + perm_flag + [f'--add-port={port}/{protocol}']
+ cmd = [command] + perm_flag + zone_flag + [f'--add-port={port}/{protocol}']
elif rule_type == 'block_ip':
ip = kwargs.get('ip')
if not ip:
return {'success': False, 'error': 'IP address required'}
- cmd = ['firewall-cmd'] + perm_flag + [
+ cmd = [command] + perm_flag + zone_flag + [
f'--add-rich-rule=rule family="ipv4" source address="{ip}" reject'
]
@@ -501,14 +566,20 @@ class FirewallService:
if not ip:
return {'success': False, 'error': 'IP address required'}
if port:
- cmd = ['firewall-cmd'] + perm_flag + [
+ cmd = [command] + perm_flag + zone_flag + [
f'--add-rich-rule=rule family="ipv4" source address="{ip}" port port="{port}" protocol="tcp" accept'
]
else:
- cmd = ['firewall-cmd'] + perm_flag + [
+ cmd = [command] + perm_flag + zone_flag + [
f'--add-rich-rule=rule family="ipv4" source address="{ip}" accept'
]
+ elif rule_type == 'rich':
+ rule = kwargs.get('rule')
+ if not rule:
+ return {'success': False, 'error': 'Rich rule required'}
+ cmd = [command] + perm_flag + zone_flag + [f'--add-rich-rule={rule}']
+
else:
return {'success': False, 'error': f'Unknown rule type: {rule_type}'}
@@ -516,7 +587,7 @@ class FirewallService:
if result.returncode == 0:
# Reload if permanent
- if permanent:
+ if permanent and not offline:
run_privileged(['firewall-cmd', '--reload'])
return {'success': True, 'message': 'Rule added successfully'}
@@ -785,6 +856,10 @@ class FirewallService:
if firewall not in ('firewalld', 'ufw'):
return {'success': False, 'error': 'No firewall detected'}
+ error = cls._validate_rule_request(rule_type, kwargs, removing=True)
+ if error:
+ return {'success': False, 'error': error}
+
if not force:
preflight = cls.check_ssh_rule_removal(rule_type, **kwargs)
if not preflight['safe']:
@@ -797,7 +872,9 @@ class FirewallService:
'override': 'Send force=true to remove it anyway.',
}
+ cls._checkpoint('remove_rule', cls._rule_label(rule_type, kwargs))
if firewall == 'firewalld':
+ kwargs['_offline'] = status.get('firewalld', {}).get('running') is False
return cls._remove_firewalld_rule(rule_type, **kwargs)
return cls._remove_ufw_rule(rule_type, **kwargs)
@@ -806,26 +883,29 @@ class FirewallService:
"""Remove a firewalld rule."""
try:
permanent = kwargs.get('permanent', True)
- perm_flag = ['--permanent'] if permanent else []
+ offline = bool(kwargs.get('_offline'))
+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'
+ perm_flag = ['--permanent'] if permanent and not offline else []
+ zone_flag = [f'--zone={kwargs["zone"]}'] if kwargs.get('zone') else []
if rule_type == 'service':
service = kwargs.get('service')
- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-service={service}']
+ cmd = [command] + perm_flag + zone_flag + [f'--remove-service={service}']
elif rule_type == 'port':
port = kwargs.get('port')
protocol = kwargs.get('protocol', 'tcp')
- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-port={port}/{protocol}']
+ cmd = [command] + perm_flag + zone_flag + [f'--remove-port={port}/{protocol}']
elif rule_type == 'block_ip':
ip = kwargs.get('ip')
- cmd = ['firewall-cmd'] + perm_flag + [
+ cmd = [command] + perm_flag + zone_flag + [
f'--remove-rich-rule=rule family="ipv4" source address="{ip}" reject'
]
elif rule_type == 'rich':
rule = kwargs.get('rule')
- cmd = ['firewall-cmd'] + perm_flag + [f'--remove-rich-rule={rule}']
+ cmd = [command] + perm_flag + zone_flag + [f'--remove-rich-rule={rule}']
else:
return {'success': False, 'error': f'Unknown rule type: {rule_type}'}
@@ -833,7 +913,7 @@ class FirewallService:
result = run_privileged(cmd)
if result.returncode == 0:
- if permanent:
+ if permanent and not offline:
run_privileged(['firewall-cmd', '--reload'])
return {'success': True, 'message': 'Rule removed successfully'}
@@ -858,6 +938,17 @@ class FirewallService:
elif rule_type == 'block_ip':
ip = kwargs.get('ip')
result = run_privileged(['ufw', 'delete', 'deny', 'from', ip])
+ elif rule_type == 'service':
+ service = kwargs.get('service')
+ action = kwargs.get('action', 'allow')
+ result = run_privileged(['ufw', 'delete', action, service])
+ elif rule_type == 'allow_ip':
+ ip = kwargs.get('ip')
+ port = kwargs.get('port')
+ cmd = ['ufw', 'delete', 'allow', 'from', ip]
+ if port:
+ cmd.extend(['to', 'any', 'port', str(port)])
+ result = run_privileged(cmd)
else:
return {'success': False, 'error': 'Rule number or specification required'}
@@ -1140,13 +1231,34 @@ class FirewallService:
}
try:
- result = run_privileged(['firewall-cmd', f'--set-default-zone={zone}'])
+ status = cls.get_status()
+ offline = status.get('firewalld', {}).get('running') is False
+ command = 'firewall-offline-cmd' if offline else 'firewall-cmd'
+ cls._checkpoint('set_default_zone', zone)
+ result = run_privileged([command, f'--set-default-zone={zone}'])
if result.returncode == 0:
return {'success': True, 'message': f'Default zone set to {zone}'}
return {'success': False, 'error': result.stderr or 'Failed to set default zone'}
except Exception as e:
return {'success': False, 'error': str(e)}
+ @classmethod
+ def set_default_incoming(cls, allow: bool) -> Dict:
+ """Converge UFW's persisted default incoming policy."""
+ cls._checkpoint('set_default_incoming', 'allow' if allow else 'deny')
+ try:
+ result = run_privileged([
+ 'ufw', 'default', 'allow' if allow else 'deny', 'incoming',
+ ])
+ if result.returncode == 0:
+ return {'success': True, 'allow': bool(allow)}
+ return {
+ 'success': False,
+ 'error': result.stderr or 'Failed to set UFW incoming policy',
+ }
+ except Exception as e:
+ return {'success': False, 'error': str(e)}
+
@classmethod
def install_firewall(cls, firewall: str = 'ufw') -> Dict:
"""Install a firewall."""
diff --git a/backend/app/services/nginx_service.py b/backend/app/services/nginx_service.py
index d6d6ad5d..206c1f6c 100644
--- a/backend/app/services/nginx_service.py
+++ b/backend/app/services/nginx_service.py
@@ -8,6 +8,19 @@ from app.utils.system import (ServiceControl, is_command_available,
run_privileged, write_privileged_file)
+def _auto_capture_vhost(name, action):
+ """Best-effort checkpoint for request-bound vhost lifecycle mutations."""
+ from flask import has_app_context
+
+ if not has_app_context():
+ return None
+ from app.services.restore_point_service import auto_capture, get_adapter
+
+ if get_adapter('nginx_vhost') is None:
+ return None
+ return auto_capture('nginx_vhost', name, action)
+
+
def _validate_domain(domain: str) -> bool:
"""Validate domain name to prevent nginx config injection."""
return bool(re.match(r'^(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?$', domain, re.IGNORECASE))
@@ -782,6 +795,7 @@ location /p/ {{
enabled_path = os.path.join(cls.SITES_ENABLED, name)
previous = cls.read_vhost(name)
was_enabled = os.path.exists(enabled_path)
+ _auto_capture_vhost(name, 'write_vhost')
written = write_privileged_file(available_path, content)
if not written['success']:
@@ -833,6 +847,8 @@ location /p/ {{
if not os.path.exists(available_path):
return {'success': False, 'error': f'Site {name} not found in sites-available'}
+ _auto_capture_vhost(name, 'enable_site')
+
try:
result = run_privileged(['ln', '-sf', available_path, enabled_path])
if result.returncode == 0:
@@ -849,6 +865,7 @@ location /p/ {{
def disable_site(cls, name: str) -> Dict:
"""Disable a site by removing symlink from sites-enabled."""
enabled_path = os.path.join(cls.SITES_ENABLED, name)
+ _auto_capture_vhost(name, 'disable_site')
try:
result = run_privileged(['rm', '-f', enabled_path])
@@ -864,8 +881,11 @@ location /p/ {{
@classmethod
def delete_site(cls, name: str) -> Dict:
"""Delete a site configuration."""
+ _auto_capture_vhost(name, 'delete_site')
# First disable it
- cls.disable_site(name)
+ from app.services.restore_point_service import suppress_auto_capture
+ with suppress_auto_capture():
+ cls.disable_site(name)
available_path = os.path.join(cls.SITES_AVAILABLE, name)
try:
diff --git a/backend/app/services/restore_point_adapter_cron.py b/backend/app/services/restore_point_adapter_cron.py
new file mode 100644
index 00000000..53210eff
--- /dev/null
+++ b/backend/app/services/restore_point_adapter_cron.py
@@ -0,0 +1,100 @@
+"""Restore-point adapter for the local CRON surface.
+
+The crontab and ServerKit's JSON metadata are one logical state. Capturing
+only the rendered crontab would lose application attribution, tracking, and
+alert preferences; capturing only metadata would lose hand-written lines.
+"""
+
+from copy import deepcopy
+
+from app.services.cron_service import CronService
+
+
+SCOPE_ID = 'cron'
+
+
+def _validate_scope(scope_id, server_id):
+ if str(scope_id) != SCOPE_ID:
+ raise ValueError(f'Invalid CRON restore-point scope: {scope_id}')
+ if server_id is not None:
+ raise ValueError('Remote CRON restore points are not supported')
+
+
+def capture(scope_id, server_id=None):
+ """Return the complete readable crontab and its metadata sidecar."""
+ _validate_scope(scope_id, server_id)
+
+ if CronService.is_linux():
+ crontab = CronService._read_crontab()
+ if crontab is None:
+ raise RuntimeError('Could not read the current crontab')
+ else:
+ # Non-Linux installs use the metadata-backed scheduler and therefore
+ # have a real, readable empty system-crontab component.
+ crontab = ''
+
+ try:
+ metadata = CronService._load_jobs_metadata_strict()
+ except (OSError, ValueError) as exc:
+ raise RuntimeError('CRON metadata is unreadable or malformed') from exc
+
+ return {
+ 'crontab': crontab,
+ 'metadata': deepcopy(metadata),
+ }
+
+
+def _validate_payload(payload):
+ if not isinstance(payload, dict):
+ raise ValueError('CRON restore payload must be an object')
+ crontab = payload.get('crontab')
+ metadata = payload.get('metadata')
+ if not isinstance(crontab, str):
+ raise ValueError('CRON restore payload requires readable crontab text')
+ if not isinstance(metadata, dict) or not isinstance(metadata.get('jobs'), dict):
+ raise ValueError('CRON restore payload requires jobs metadata')
+ return crontab, deepcopy(metadata)
+
+
+def restore(scope_id, payload, actor=None, server_id=None):
+ """Restore CRON state, rolling the crontab back if metadata cannot persist.
+
+ The normal service doors remain responsible for both writes. A metadata
+ failure after installing the target crontab is compensated with the full
+ pre-image so callers never receive a false atomic-success result.
+ """
+ del actor # Actor attribution belongs to the generic restore-point service.
+ _validate_scope(scope_id, server_id)
+ target_crontab, target_metadata = _validate_payload(payload)
+ previous = capture(scope_id, server_id=server_id)
+
+ if CronService.is_linux():
+ failure = CronService._install_crontab(target_crontab)
+ if failure:
+ return failure
+
+ try:
+ CronService._save_jobs_metadata(target_metadata)
+ except Exception as exc: # noqa: BLE001 - compensate both state components
+ rollback_errors = []
+ if CronService.is_linux():
+ rollback = CronService._install_crontab(previous['crontab'])
+ if rollback:
+ rollback_errors.append(
+ rollback.get('error') or 'failed to roll back crontab')
+ try:
+ CronService._save_jobs_metadata(previous['metadata'])
+ except Exception as rollback_exc: # noqa: BLE001 - report degraded rollback
+ rollback_errors.append(
+ f'failed to roll back metadata: {rollback_exc}')
+
+ result = {
+ 'success': False,
+ 'error': f'Failed to restore CRON metadata: {exc}',
+ 'rolled_back': not rollback_errors,
+ }
+ if rollback_errors:
+ result['rollback_error'] = '; '.join(rollback_errors)
+ return result
+
+ return {'success': True, 'message': 'CRON state restored'}
diff --git a/backend/app/services/restore_point_adapter_dns.py b/backend/app/services/restore_point_adapter_dns.py
new file mode 100644
index 00000000..8db35605
--- /dev/null
+++ b/backend/app/services/restore_point_adapter_dns.py
@@ -0,0 +1,486 @@
+"""Restore-point adapter for panel-owned provider DNS records.
+
+The checkpoint intentionally reads only ``ManagedDnsRecord``. Provider-only
+records remain outside coverage and are never adopted by a restore. Replay
+uses ``DnsOwnershipService`` so the same foreign-record protection guards
+ordinary writes and restores.
+"""
+from app.models.dns_zone import DNSZone
+from app.models.email import DNSProviderConfig
+from app.models.managed_dns_record import ManagedDnsRecord
+from app.services.dns.base import DnsCredential, DnsRecordSpec
+from app.services.dns_ownership_service import (
+ DnsOwnershipService,
+ parse_dns_scope_id,
+)
+
+
+def _validate_scope(scope_id, server_id=None):
+ if server_id is not None:
+ raise ValueError('Remote DNS restore points are not supported')
+ return parse_dns_scope_id(scope_id)
+
+
+def _query(provider, config_id, provider_zone_id):
+ query = ManagedDnsRecord.query.filter_by(
+ provider=provider,
+ provider_zone_id=provider_zone_id,
+ )
+ if config_id is None:
+ query = query.filter(ManagedDnsRecord.dns_provider_config_id.is_(None))
+ else:
+ query = query.filter_by(dns_provider_config_id=config_id)
+ return query
+
+
+def _record_payload(row):
+ return DnsOwnershipService.record_payload(row)
+
+
+def capture(scope_id, server_id=None):
+ """Capture exactly the managed ledger rows for one provider connection/zone."""
+ provider, config_id, provider_zone_id = _validate_scope(scope_id, server_id)
+ rows = _query(provider, config_id, provider_zone_id).order_by(
+ ManagedDnsRecord.record_type,
+ ManagedDnsRecord.name,
+ ManagedDnsRecord.id,
+ ).all()
+ return {
+ 'provider': provider,
+ 'config_id': config_id,
+ 'provider_zone_id': provider_zone_id,
+ 'records': [_record_payload(row) for row in rows],
+ }
+
+
+def _record_map(payload, *, expected_scope=None):
+ if not isinstance(payload, dict):
+ raise ValueError('DNS restore payload must be an object')
+ required = ('provider', 'config_id', 'provider_zone_id', 'records')
+ if any(key not in payload for key in required):
+ raise ValueError('DNS restore payload is incomplete')
+
+ if expected_scope is not None:
+ provider, config_id, provider_zone_id = expected_scope
+ if (
+ str(payload.get('provider')).lower() != provider
+ or payload.get('config_id') != config_id
+ or str(payload.get('provider_zone_id')) != provider_zone_id
+ ):
+ raise ValueError('DNS restore payload belongs to a different scope')
+
+ records = payload.get('records')
+ if not isinstance(records, list):
+ raise ValueError('DNS restore payload.records must be a list')
+
+ out = {}
+ for item in records:
+ if not isinstance(item, dict):
+ raise ValueError('DNS restore records must be objects')
+ record_type = str(item.get('record_type') or '').upper()
+ name = str(item.get('name') or '').lower().rstrip('.')
+ if not record_type or not name or item.get('content') is None:
+ raise ValueError('DNS restore record requires type, name, and content')
+ key = (record_type, name)
+ if key in out:
+ raise ValueError(f'DNS restore payload repeats RRset {record_type} {name}')
+ normalized = {
+ 'record_type': record_type,
+ 'name': name,
+ 'content': str(item.get('content')),
+ 'ttl': item.get('ttl'),
+ 'priority': item.get('priority'),
+ 'proxied': item.get('proxied'),
+ 'source': item.get('source'),
+ 'app_id': item.get('app_id'),
+ }
+ if normalized['proxied'] not in (None, True, False):
+ raise ValueError(
+ f'DNS restore record {record_type} {name} has invalid proxy state',
+ )
+ try:
+ normalized['ttl'] = (int(normalized['ttl'])
+ if normalized['ttl'] is not None else None)
+ normalized['priority'] = (
+ int(normalized['priority'])
+ if normalized['priority'] is not None else None
+ )
+ except (TypeError, ValueError) as exc:
+ raise ValueError(
+ f'DNS restore record {record_type} {name} has invalid numeric fields',
+ ) from exc
+ out[key] = normalized
+ return out
+
+
+def _display_key(key):
+ return f'{key[0]} {key[1]}'
+
+
+def diff(old_payload, new_payload):
+ """Return the common added/removed/changed vocabulary per DNS RRset."""
+ old = _record_map(old_payload)
+ new = _record_map(new_payload)
+ old_keys = set(old)
+ new_keys = set(new)
+ return {
+ 'added': {
+ _display_key(key): new[key] for key in sorted(new_keys - old_keys)
+ },
+ 'removed': {
+ _display_key(key): old[key] for key in sorted(old_keys - new_keys)
+ },
+ 'changed': {
+ _display_key(key): {'old': old[key], 'new': new[key]}
+ for key in sorted(old_keys & new_keys)
+ if old[key] != new[key]
+ },
+ }
+
+
+def _legacy_credential(provider, provider_zone_id):
+ zone = DNSZone.query.filter_by(
+ provider=provider,
+ provider_zone_id=provider_zone_id,
+ dns_provider_config_id=None,
+ ).first()
+ if zone is None:
+ raise ValueError('Legacy DNS zone credential not found')
+ data = zone.provider_config or {}
+ token = data.get('api_token') or data.get('api_key') or data.get('token')
+ if not token:
+ raise ValueError('Legacy DNS zone has no usable credential')
+ return DnsCredential(
+ provider=provider,
+ token=token,
+ email=data.get('api_email') or data.get('email'),
+ secret=data.get('api_secret') or data.get('secret'),
+ )
+
+
+def _client_for_scope(provider, config_id, provider_zone_id):
+ from app.services.dns import get_record_client
+
+ if config_id is None:
+ credential = _legacy_credential(provider, provider_zone_id)
+ else:
+ config = DNSProviderConfig.query.get(config_id)
+ if config is None:
+ raise ValueError(f'DNS provider connection {config_id} not found')
+ if config.provider.lower() != provider:
+ raise ValueError('DNS provider connection does not match restore scope')
+ credential = DnsCredential.from_provider_config(config)
+ return get_record_client(credential)
+
+
+def _existing_id(client, provider_zone_id, record):
+ caa = None
+ if record['record_type'] == 'CAA':
+ from app.services.dns.cloudflare import parse_caa_value
+ caa = parse_caa_value(record['content'])
+ return client.find_record_id(
+ provider_zone_id, record['record_type'], record['name'], caa=caa,
+ )
+
+
+def _foreign_conflicts(client, provider, config_id, provider_zone_id,
+ target, current_rows):
+ """Preflight every target before the first write to avoid partial replay."""
+ conflicts = []
+ existing_ids = {}
+ for key, record in sorted(target.items()):
+ existing_id = _existing_id(client, provider_zone_id, record)
+ existing_ids[key] = existing_id
+ if not existing_id:
+ continue
+ row = current_rows.get(key)
+ owns_id = DnsOwnershipService.owns(
+ provider_zone_id, provider_record_id=existing_id,
+ provider=provider, config_id=config_id,
+ )
+ if not owns_id and not (row is not None and not row.provider_record_id):
+ conflicts.append(_display_key(key))
+ return conflicts, existing_ids
+
+
+def _live_record_map(client, provider_zone_id):
+ result = client.list_records(provider_zone_id)
+ if not result.get('success'):
+ raise RuntimeError(
+ result.get('error') or 'Provider live DNS records are unavailable',
+ )
+ out = {}
+ for row in result.get('records', []):
+ key = (
+ str(row.get('type') or '').upper(),
+ str(row.get('name') or '').lower().rstrip('.'),
+ )
+ if key[0] and key[1]:
+ out.setdefault(key, row)
+ return out
+
+
+def _prepare_target(client, provider, provider_zone_id, target):
+ """Hydrate nullable migration-092 fields without fabricating live state."""
+ needs_live = any(
+ item.get('ttl') is None
+ or (provider == 'cloudflare' and item.get('proxied') is None)
+ or (
+ item.get('record_type') in ('MX', 'SRV')
+ and item.get('priority') is None
+ and not str(item.get('content') or '').partition(' ')[0].isdigit()
+ )
+ for item in target.values()
+ )
+ live = {}
+ if needs_live:
+ try:
+ live = _live_record_map(client, provider_zone_id)
+ except Exception as exc: # noqa: BLE001 - preview should explain refusal
+ return target, [
+ 'Legacy DNS record attributes are unknown and live provider '
+ f'state could not be read safely: {exc}',
+ ]
+
+ prepared = {}
+ refusals = []
+ for key, original in target.items():
+ item = dict(original)
+ live_row = live.get(key)
+
+ if item.get('ttl') is None:
+ if live_row is None or live_row.get('ttl') is None:
+ refusals.append(
+ f'{_display_key(key)} has unknown legacy TTL and no live '
+ 'provider value; restore cannot safely invent one.'
+ )
+ else:
+ item['ttl'] = int(live_row['ttl'])
+
+ if provider == 'cloudflare' and item.get('proxied') is None:
+ if live_row is None or live_row.get('proxied') is None:
+ refusals.append(
+ f'{_display_key(key)} has unknown legacy proxy state and '
+ 'no live provider value; restore cannot safely disable it.'
+ )
+ else:
+ item['proxied'] = bool(live_row['proxied'])
+
+ if (
+ item['record_type'] in ('MX', 'SRV')
+ and item.get('priority') is None
+ and not item['content'].partition(' ')[0].isdigit()
+ ):
+ if live_row is None or live_row.get('priority') is None:
+ refusals.append(
+ f'{_display_key(key)} has unknown legacy priority and no '
+ 'live provider value; restore cannot safely invent one.'
+ )
+ else:
+ item['priority'] = int(live_row['priority'])
+
+ prepared[key] = item
+ return prepared, refusals
+
+
+def _canonical_live_content(record_type, content):
+ value = str(content or '').strip()
+ if record_type in ('CNAME', 'MX', 'NS', 'PTR', 'SRV'):
+ return value.rstrip('.').lower()
+ if record_type == 'CAA':
+ return value.lower()
+ return value
+
+
+def _content_and_priority(record_type, content, priority):
+ value = str(content or '').strip()
+ effective_priority = priority
+ if record_type in ('MX', 'SRV') and effective_priority is None:
+ head, _, rest = value.partition(' ')
+ if head.isdigit() and rest.strip():
+ effective_priority = int(head)
+ value = rest.strip()
+ return _canonical_live_content(record_type, value), effective_priority
+
+
+def _synthetic_delete_matches(row, live_row):
+ ledger_content, ledger_priority = _content_and_priority(
+ row.record_type, row.content, row.priority,
+ )
+ live_content, live_priority = _content_and_priority(
+ row.record_type, live_row.get('content'), live_row.get('priority'),
+ )
+ if (
+ ledger_content != live_content
+ ):
+ return False
+ comparisons = (
+ ('ttl', row.ttl),
+ ('priority', ledger_priority),
+ ('proxied', row.proxied),
+ )
+ for key, expected in comparisons:
+ actual = live_priority if key == 'priority' else live_row.get(key)
+ if expected is not None and actual is not None and expected != actual:
+ return False
+ return True
+
+
+def _delete_refusals(client, provider, provider_zone_id, target, current_rows):
+ """Never delete a provider-side replacement merely because its RRset is ours."""
+ delete_keys = sorted(set(current_rows) - set(target))
+ if not delete_keys:
+ return []
+ try:
+ live = _live_record_map(client, provider_zone_id)
+ except Exception as exc: # noqa: BLE001 - inability to prove safety refuses
+ return [
+ 'Provider live DNS state could not be read, so restore cannot '
+ f'safely delete managed records: {exc}',
+ ]
+
+ refusals = []
+ stable_id_provider = provider in ('cloudflare', 'digitalocean')
+ for key in delete_keys:
+ row = current_rows[key]
+ live_row = live.get(key)
+ if live_row is None:
+ continue
+ if stable_id_provider and row.provider_record_id:
+ if str(live_row.get('id')) != str(row.provider_record_id):
+ refusals.append(
+ f'Restore would delete provider-only replacement '
+ f'{_display_key(key)}; its provider id no longer matches.'
+ )
+ elif not _synthetic_delete_matches(row, live_row):
+ refusals.append(
+ f'Restore would delete provider-only replacement '
+ f'{_display_key(key)}; its live value no longer matches the ledger.'
+ )
+ return refusals
+
+
+def validate_restore(scope_id, payload, current_payload, actor=None,
+ server_id=None):
+ """Surface foreign-record refusals during preview, before restore is offered."""
+ del actor, current_payload
+ scope = _validate_scope(scope_id, server_id)
+ provider, config_id, provider_zone_id = scope
+ target = _record_map(payload, expected_scope=scope)
+ client = _client_for_scope(provider, config_id, provider_zone_id)
+ current_rows = {
+ ((row.record_type or '').upper(), (row.name or '').lower().rstrip('.')): row
+ for row in _query(provider, config_id, provider_zone_id).all()
+ }
+ _, attribute_refusals = _prepare_target(
+ client, provider, provider_zone_id, target,
+ )
+ conflicts, _ = _foreign_conflicts(
+ client, provider, config_id, provider_zone_id, target, current_rows,
+ )
+ delete_refusals = _delete_refusals(
+ client, provider, provider_zone_id, target, current_rows,
+ )
+ return attribute_refusals + delete_refusals + [
+ 'Restore would overwrite provider-only DNS record '
+ f'{record}; it was not created by ServerKit.'
+ for record in conflicts
+ ]
+
+
+def restore(scope_id, payload, actor=None, server_id=None):
+ """Re-converge owned RRsets while refusing to touch provider-only records."""
+ del actor # Generic restore auditing owns actor attribution.
+ scope = _validate_scope(scope_id, server_id)
+ provider, config_id, provider_zone_id = scope
+ target = _record_map(payload, expected_scope=scope)
+ client = _client_for_scope(provider, config_id, provider_zone_id)
+
+ current_rows = {
+ ((row.record_type or '').upper(), (row.name or '').lower().rstrip('.')): row
+ for row in _query(provider, config_id, provider_zone_id).all()
+ }
+ target, attribute_refusals = _prepare_target(
+ client, provider, provider_zone_id, target,
+ )
+ conflicts, existing_ids = _foreign_conflicts(
+ client, provider, config_id, provider_zone_id, target, current_rows,
+ )
+ delete_refusals = _delete_refusals(
+ client, provider, provider_zone_id, target, current_rows,
+ )
+ if conflicts or attribute_refusals or delete_refusals:
+ errors = list(attribute_refusals) + list(delete_refusals)
+ if conflicts:
+ errors.append(
+ 'Restore refused to overwrite provider-only DNS records: '
+ + ', '.join(conflicts)
+ )
+ return {
+ 'success': False,
+ 'conflict': bool(conflicts),
+ 'refused': True,
+ 'error': '; '.join(errors),
+ 'conflicts': conflicts,
+ }
+
+ restored = []
+ removed = []
+ results = []
+
+ for key in sorted(target):
+ item = target[key]
+ # The ledger is the capture source, not proof that provider live state
+ # still matches. Always send the idempotent guarded upsert so deleted or
+ # drifted managed records are repaired during restore.
+ spec = DnsRecordSpec(
+ record_type=item['record_type'],
+ name=item['name'],
+ content=item['content'],
+ ttl=item['ttl'],
+ priority=item['priority'],
+ proxied=item['proxied'],
+ )
+ result = DnsOwnershipService.guarded_upsert(
+ client, provider=provider, provider_zone_id=provider_zone_id,
+ spec=spec, source=item.get('source') or 'restore',
+ app_id=item.get('app_id'), config_id=config_id,
+ # Provider live state, not the ledger, decides whether an id is
+ # still usable. A stale id must become a create, never a PUT to a
+ # provider-deleted object.
+ known_record_id=existing_ids.get(key),
+ allow_foreign=False,
+ )
+ results.append({'action': 'upsert', 'record': _display_key(key), **result})
+ if not result.get('success'):
+ return {
+ 'success': False,
+ 'error': result.get('error', 'DNS restore upsert failed'),
+ 'results': results,
+ }
+ restored.append(_display_key(key))
+
+ for key in sorted(set(current_rows) - set(target)):
+ row = current_rows[key]
+ result = DnsOwnershipService.guarded_delete(
+ client, provider=provider, provider_zone_id=provider_zone_id,
+ record_type=row.record_type, name=row.name,
+ provider_record_id=row.provider_record_id,
+ source='restore', config_id=config_id,
+ )
+ results.append({'action': 'delete', 'record': _display_key(key), **result})
+ if not result.get('success'):
+ return {
+ 'success': False,
+ 'error': result.get('error', 'DNS restore delete failed'),
+ 'results': results,
+ }
+ removed.append(_display_key(key))
+
+ return {
+ 'success': True,
+ 'scope_id': scope_id,
+ 'restored': restored,
+ 'removed': removed,
+ 'results': results,
+ }
diff --git a/backend/app/services/restore_point_adapter_env.py b/backend/app/services/restore_point_adapter_env.py
new file mode 100644
index 00000000..5d8a14c7
--- /dev/null
+++ b/backend/app/services/restore_point_adapter_env.py
@@ -0,0 +1,233 @@
+"""Restore-point adapter for an application's local environment variables.
+
+The payload deliberately stores metadata and references, but never plaintext
+for a secret-flagged or sensitive-looking key. Restore replays through
+``EnvService`` so encryption, history, and future policy remain centralized.
+"""
+
+from app.models import Application, EnvironmentVariable
+from app.services.configuration_service import ConfigurationService
+from app.utils.sensitive_data_filter import MASK
+
+
+coverage = (
+ 'Only environment variables set directly on this application are '
+ 'captured. Shared variable groups and their attachment order are outside '
+ 'this checkpoint.',
+)
+
+
+def _application_id(scope_id):
+ try:
+ return int(scope_id)
+ except (TypeError, ValueError) as exc:
+ raise ValueError(f'Invalid application environment scope: {scope_id}') from exc
+
+
+def _require_application(scope_id):
+ application_id = _application_id(scope_id)
+ application = Application.query_active().filter_by(id=application_id).first()
+ if application is None:
+ raise ValueError(f'Application {application_id} not found')
+ return application_id
+
+
+def _masked_value(env_var):
+ """Avoid decrypting rows that ConfigurationService will redact anyway."""
+ placeholder = ConfigurationService.mask_env_value(
+ env_var.key, '', bool(env_var.is_secret),
+ )
+ if placeholder == MASK:
+ return MASK
+ return ConfigurationService.mask_env_value(
+ env_var.key, env_var.value, bool(env_var.is_secret),
+ )
+
+
+def capture(scope_id, server_id=None):
+ """Capture a deterministic, secret-safe per-key environment mapping."""
+ del server_id # Environment variables are scoped by application today.
+ application_id = _require_application(scope_id)
+ rows = EnvironmentVariable.query.filter_by(
+ application_id=application_id,
+ ).order_by(EnvironmentVariable.key).all()
+
+ env = {}
+ for row in rows:
+ env[row.key] = {
+ 'value': _masked_value(row),
+ 'is_secret': bool(row.is_secret),
+ 'description': row.description,
+ 'target_service': row.target_service,
+ # References contain source identity, never the resolved secret.
+ 'value_from': row.get_reference(),
+ }
+ return {'env': env}
+
+
+def _env_mapping(payload):
+ if not isinstance(payload, dict):
+ raise ValueError('Environment restore payload must be an object')
+ env = payload.get('env', {})
+ if not isinstance(env, dict):
+ raise ValueError('Environment restore payload.env must be an object')
+ return env
+
+
+def diff(old_payload, new_payload):
+ """Return the shared added/removed/changed vocabulary at key granularity."""
+ old = _env_mapping(old_payload)
+ new = _env_mapping(new_payload)
+ old_keys = set(old)
+ new_keys = set(new)
+ return {
+ 'added': {key: new[key] for key in sorted(new_keys - old_keys)},
+ 'removed': {key: old[key] for key in sorted(old_keys - new_keys)},
+ 'changed': {
+ key: {'old': old[key], 'new': new[key]}
+ for key in sorted(old_keys & new_keys)
+ if old[key] != new[key]
+ },
+ }
+
+
+def _validate_target(target):
+ """Validate the full target before the first replay write."""
+ for key, item in target.items():
+ if not isinstance(key, str) or not isinstance(item, dict):
+ raise ValueError('Environment restore entries must be keyed objects')
+ valid, error = _env_service().validate_key(key)
+ if not valid:
+ raise ValueError(f'{key}: {error}')
+ reference = item.get('value_from')
+ if reference is not None and not isinstance(reference, dict):
+ raise ValueError(f'{key}: value_from must be an object or null')
+
+
+def _env_service():
+ # Lazy to avoid coupling the normal environment-service import path back
+ # through the adapter registry during application startup.
+ from app.services.env_service import EnvService
+
+ return EnvService
+
+
+def _actor_id(actor):
+ return getattr(actor, 'id', actor)
+
+
+def restore(scope_id, payload, actor=None, server_id=None):
+ """Re-converge local env state without clobbering masked live material."""
+ del server_id
+ application_id = _require_application(scope_id)
+ target = _env_mapping(payload)
+ _validate_target(target)
+
+ from app.services.env_service import _new_batch_id
+ from app.services.restore_point_service import suppress_auto_capture
+
+ EnvService = _env_service()
+ actor_id = _actor_id(actor)
+ batch_id = _new_batch_id()
+ current = {
+ row.key: row for row in EnvironmentVariable.query.filter_by(
+ application_id=application_id,
+ ).all()
+ }
+
+ restored = []
+ removed = []
+ skipped_secrets = []
+ preserved_references = []
+
+ # The generic restore service already suppresses nested auto-captures.
+ # Keep the adapter safe when exercised directly as well.
+ with suppress_auto_capture():
+ for key in sorted(target):
+ item = target[key]
+ reference = item.get('value_from')
+ value = item.get('value', '')
+
+ if reference is not None:
+ _, _, error = EnvService.set_env_reference(
+ application_id,
+ key,
+ reference,
+ user_id=actor_id,
+ target_service=item.get('target_service'),
+ description=item.get('description'),
+ batch_id=batch_id,
+ )
+ if error:
+ raise ValueError(f'{key}: {error}')
+ restored.append(key)
+ continue
+
+ if value == MASK:
+ # There is no recoverable value in the checkpoint. If a live
+ # row exists, leave its literal/reference and metadata intact;
+ # if it is missing, do not manufacture a row containing MASK.
+ skipped_secrets.append(key)
+ if current.get(key) and current[key].get_reference():
+ preserved_references.append(key)
+ continue
+
+ _, _, error = EnvService.set_env_var(
+ application_id,
+ key,
+ value,
+ is_secret=bool(item.get('is_secret', False)),
+ description=item.get('description'),
+ user_id=actor_id,
+ target_service=item.get('target_service'),
+ batch_id=batch_id,
+ )
+ if error:
+ raise ValueError(f'{key}: {error}')
+ # ``set_env_var`` deliberately treats description=None as
+ # "leave unchanged" for its longstanding callers. A checkpoint's
+ # explicit null means clear it, so finish that metadata convergence
+ # through the partial-update service door.
+ if (
+ item.get('description') is None
+ and current.get(key)
+ and current[key].description is not None
+ ):
+ _, error = EnvService.update_env_var(
+ application_id,
+ key,
+ description=None,
+ user_id=actor_id,
+ batch_id=batch_id,
+ )
+ if error:
+ raise ValueError(f'{key}: {error}')
+ restored.append(key)
+
+ for key in sorted(set(current) - set(target)):
+ row = current[key]
+ reference = row.get_reference()
+ if reference is not None:
+ preserved_references.append(key)
+ continue
+ if ConfigurationService.mask_env_value(
+ key, '', bool(row.is_secret),
+ ) == MASK:
+ skipped_secrets.append(key)
+ continue
+ success, error = EnvService.delete_env_var(
+ application_id, key, user_id=actor_id, batch_id=batch_id,
+ )
+ if not success:
+ raise ValueError(f'{key}: {error}')
+ removed.append(key)
+
+ return {
+ 'success': True,
+ 'application_id': application_id,
+ 'batch_id': batch_id,
+ 'restored': restored,
+ 'removed': removed,
+ 'skipped_secrets': sorted(set(skipped_secrets)),
+ 'preserved_references': sorted(set(preserved_references)),
+ }
diff --git a/backend/app/services/restore_point_adapter_firewall.py b/backend/app/services/restore_point_adapter_firewall.py
new file mode 100644
index 00000000..c12b3d08
--- /dev/null
+++ b/backend/app/services/restore_point_adapter_firewall.py
@@ -0,0 +1,324 @@
+"""Restore-point adapter for the local host firewall.
+
+The payload intentionally contains only the panel's supported, replayable
+firewall vocabulary. Runtime bans and Docker-managed chains remain outside
+the checkpoint, as stated by the frozen coverage text.
+"""
+
+import re
+
+from flask import has_request_context
+
+from app.services.firewall_service import FirewallService
+from app.utils.system import PROBE_TIMEOUT, run_privileged
+
+
+coverage = [
+ 'Restore converges persisted panel-supported UFW rules and firewalld '
+ 'service, port, and rich-rule families, including matching manually '
+ 'created rules. Other firewalld families, interfaces, sources, runtime '
+ 'bans, and Docker-managed iptables chains are left alone.',
+]
+
+
+def _run(argv):
+ result = run_privileged(argv, timeout=PROBE_TIMEOUT)
+ if result.returncode != 0:
+ message = (result.stderr or result.stdout or 'command failed').strip()
+ raise RuntimeError(f'{" ".join(argv)}: {message}')
+ return result.stdout or ''
+
+
+def _ufw_rules():
+ lines = _run(['ufw', 'show', 'added']).splitlines()
+ rules = []
+ for line in lines:
+ line = line.strip()
+ if not line.lower().startswith('ufw '):
+ continue
+ argv = line.split()[1:]
+ if argv:
+ rules.append({'kind': 'ufw', 'argv': argv})
+ return sorted(rules, key=_rule_key)
+
+
+def _firewalld_rules(running, zones):
+ command = 'firewall-cmd' if running else 'firewall-offline-cmd'
+ persistent = ['--permanent'] if running else []
+ rules = []
+ for zone_name in sorted(set(zones)):
+ zone = [f'--zone={zone_name}']
+ for value in _run([command] + persistent + zone + ['--list-services']).split():
+ rules.append({
+ 'kind': 'service', 'service': value, 'zone': zone_name,
+ 'permanent': True,
+ })
+ for value in _run([command] + persistent + zone + ['--list-ports']).split():
+ port, _, protocol = value.partition('/')
+ rules.append({
+ 'kind': 'port', 'port': port, 'protocol': protocol or 'tcp',
+ 'zone': zone_name, 'permanent': True,
+ })
+ rich = _run([command] + persistent + zone + ['--list-rich-rules'])
+ for value in rich.splitlines():
+ if value.strip():
+ rules.append({
+ 'kind': 'rich', 'rule': value.strip(), 'zone': zone_name,
+ 'permanent': True,
+ })
+ return sorted(rules, key=_rule_key)
+
+
+def capture(scope_id, server_id=None):
+ if str(scope_id) != 'firewall':
+ raise ValueError('the firewall adapter only supports scope_id=firewall')
+ if server_id is not None:
+ raise ValueError('remote firewall restore points are not supported')
+ status = FirewallService.get_status()
+ firewall = status.get('active_firewall')
+ if firewall not in ('ufw', 'firewalld'):
+ raise RuntimeError('no supported local firewall is installed')
+
+ if firewall == 'ufw':
+ active = status.get('ufw', {}).get('active')
+ if active is None:
+ raise RuntimeError('could not determine whether ufw is active')
+ default_policy = FirewallService._ufw_default_incoming_policy()
+ if default_policy is None:
+ raise RuntimeError('could not read the UFW default incoming policy')
+ return {
+ 'version': 1,
+ 'firewall': 'ufw',
+ 'enabled': bool(active),
+ 'default_zone': None,
+ 'default_incoming_allow': default_policy,
+ 'rules': _ufw_rules(),
+ }
+
+ running = status.get('firewalld', {}).get('running')
+ if running is None:
+ raise RuntimeError('could not determine whether firewalld is running')
+ command = 'firewall-cmd' if running else 'firewall-offline-cmd'
+ default_zone = (status.get('firewalld', {}).get('default_zone') or
+ _run([command, '--get-default-zone']).strip())
+ if not default_zone:
+ raise RuntimeError('could not determine the firewalld default zone')
+ zones = _run([command] + (['--permanent'] if running else []) + [
+ '--get-zones',
+ ]).split()
+ if default_zone not in zones:
+ zones.append(default_zone)
+ return {
+ 'version': 1,
+ 'firewall': 'firewalld',
+ 'enabled': bool(running),
+ 'default_zone': default_zone,
+ 'default_incoming_allow': None,
+ 'rules': _firewalld_rules(bool(running), zones),
+ }
+
+
+def _rule_key(rule):
+ return repr(sorted(rule.items()))
+
+
+def _ufw_spec(rule):
+ argv = list(rule.get('argv') or [])
+ if not argv:
+ return None
+ action = argv[0].lower()
+ if action in ('allow', 'deny') and len(argv) == 2:
+ target = argv[1]
+ match = re.fullmatch(r'(\d{1,5})(?:/(tcp|udp))?', target, re.I)
+ if match:
+ return ('port', {
+ 'port': int(match.group(1)),
+ 'protocol': (match.group(2) or 'tcp').lower(),
+ 'action': action,
+ })
+ return ('service', {'service': target, 'action': action})
+ if len(argv) >= 3 and argv[1].lower() == 'from':
+ address = argv[2]
+ if action == 'deny' and len(argv) == 3:
+ return ('block_ip', {'ip': address})
+ if action == 'allow':
+ values = {'ip': address}
+ if 'port' in [part.lower() for part in argv]:
+ index = [part.lower() for part in argv].index('port')
+ if index + 1 < len(argv):
+ values['port'] = int(argv[index + 1])
+ return ('allow_ip', values)
+ return None
+
+
+def _door_spec(rule):
+ if rule.get('kind') == 'ufw':
+ return _ufw_spec(rule)
+ kind = rule.get('kind')
+ values = {
+ key: rule[key]
+ for key in ('service', 'port', 'protocol', 'rule', 'zone', 'permanent')
+ if key in rule
+ }
+ return (kind, values) if kind in ('service', 'port', 'rich') else None
+
+
+def _ssh_coverage(payload, ssh_ports):
+ if payload.get('firewall') == 'ufw':
+ if payload.get('default_incoming_allow'):
+ return set(ssh_ports)
+ covered = set()
+ for rule in payload.get('rules') or []:
+ spec = _ufw_spec(rule)
+ if not spec:
+ continue
+ kind, values = spec
+ if values.get('action', 'allow') != 'allow':
+ continue
+ if kind == 'port' and int(values['port']) in ssh_ports:
+ covered.add(int(values['port']))
+ elif kind == 'service':
+ covered.update(
+ FirewallService._app_profile_ports(values['service']) & set(ssh_ports)
+ )
+ return covered
+
+ covered = set()
+ for rule in payload.get('rules') or []:
+ if rule.get('zone') != payload.get('default_zone'):
+ continue
+ if rule.get('kind') == 'service' and rule.get('service') == 'ssh':
+ covered.update(ssh_ports)
+ elif rule.get('kind') == 'port':
+ try:
+ port = int(rule.get('port'))
+ except (TypeError, ValueError):
+ continue
+ if port in ssh_ports:
+ covered.add(port)
+ return covered
+
+
+def _blocked_networks(payload):
+ for rule in payload.get('rules') or []:
+ if rule.get('kind') == 'ufw':
+ spec = _ufw_spec(rule)
+ if spec and spec[0] == 'block_ip':
+ yield spec[1]['ip']
+ elif rule.get('kind') == 'rich':
+ text = rule.get('rule') or ''
+ if re.search(r'\b(reject|drop)\b', text, re.I):
+ match = re.search(r'source\s+address="([^"]+)"', text, re.I)
+ if match:
+ yield match.group(1)
+
+
+def validate_restore(scope_id, payload, current_payload, actor=None, server_id=None):
+ refusals = []
+ if payload.get('version') != 1:
+ refusals.append('The firewall restore-point format is unsupported.')
+ if payload.get('firewall') not in ('ufw', 'firewalld'):
+ refusals.append('The checkpoint does not name a supported firewall.')
+ if payload.get('firewall') != current_payload.get('firewall'):
+ refusals.append('Restoring across different firewall implementations is refused.')
+ unsupported = [rule for rule in payload.get('rules') or [] if not _door_spec(rule)]
+ if unsupported:
+ refusals.append('The checkpoint contains firewall rules the panel cannot replay safely.')
+
+ if payload.get('enabled'):
+ ssh_ports = FirewallService.ssh_ports()
+ if ssh_ports is None:
+ refusals.append(
+ 'Could not determine the live SSH ports, so enabling this ruleset is unsafe.'
+ )
+ elif set(ssh_ports) - _ssh_coverage(payload, ssh_ports):
+ missing = ', '.join(str(port) for port in sorted(
+ set(ssh_ports) - _ssh_coverage(payload, ssh_ports)
+ ))
+ refusals.append(f'The target ruleset does not admit SSH on port {missing}.')
+
+ protected = {'127.0.0.1', '::1'} | FirewallService.active_ssh_peers()
+ if has_request_context():
+ from app.utils.client_ip import get_client_ip
+ if get_client_ip():
+ protected.add(get_client_ip())
+ for network in _blocked_networks(payload):
+ conflicts = [address for address in sorted(protected)
+ if FirewallService._covers_address(network, address)]
+ if conflicts:
+ refusals.append(
+ f'The target ruleset blocks a protected live address ({", ".join(conflicts)}).'
+ )
+ return refusals
+
+
+def _apply(rule, removing=False):
+ spec = _door_spec(rule)
+ if spec is None:
+ raise RuntimeError('firewall rule is not replayable')
+ kind, values = spec
+ operation = FirewallService.remove_rule if removing else FirewallService.add_rule
+ if removing:
+ result = operation(kind, force=True, **values)
+ else:
+ result = operation(kind, **values)
+ if not result.get('success'):
+ raise RuntimeError(result.get('error') or 'firewall rule replay failed')
+
+
+def _is_ssh_admission(rule, ssh_ports):
+ if rule.get('kind') == 'service' and rule.get('service') == 'ssh':
+ return True
+ spec = _door_spec(rule)
+ if not spec:
+ return False
+ kind, values = spec
+ return (kind == 'port' and values.get('action', 'allow') == 'allow'
+ and int(values.get('port')) in set(ssh_ports or []))
+
+
+def restore(scope_id, payload, actor=None, server_id=None):
+ current = capture(scope_id, server_id=server_id)
+ target_rules = {_rule_key(rule): rule for rule in payload.get('rules') or []}
+ current_rules = {_rule_key(rule): rule for rule in current.get('rules') or []}
+ additions = [target_rules[key] for key in sorted(target_rules.keys() - current_rules.keys())]
+ removals = [current_rules[key] for key in sorted(current_rules.keys() - target_rules.keys())]
+
+ disabled_first = False
+ if not payload.get('enabled') and current.get('enabled'):
+ result = FirewallService.disable(payload.get('firewall'))
+ if not result.get('success'):
+ raise RuntimeError(result.get('error') or 'firewall disable failed')
+ disabled_first = True
+
+ ssh_ports = FirewallService.ssh_ports() or []
+ additions.sort(key=lambda rule: (not _is_ssh_admission(rule, ssh_ports), _rule_key(rule)))
+ for rule in additions:
+ _apply(rule)
+
+ if payload.get('firewall') == 'firewalld' \
+ and payload.get('default_zone') != current.get('default_zone'):
+ result = FirewallService.set_default_zone(payload['default_zone'], force=True)
+ if not result.get('success'):
+ raise RuntimeError(result.get('error') or 'default-zone restore failed')
+ elif payload.get('firewall') == 'ufw' \
+ and payload.get('default_incoming_allow') != current.get('default_incoming_allow'):
+ result = FirewallService.set_default_incoming(
+ bool(payload.get('default_incoming_allow')),
+ )
+ if not result.get('success'):
+ raise RuntimeError(result.get('error') or 'default-policy restore failed')
+
+ for rule in removals:
+ _apply(rule, removing=True)
+
+ if bool(payload.get('enabled')) != bool(current.get('enabled')):
+ operation = FirewallService.enable if payload.get('enabled') else FirewallService.disable
+ result = operation(payload.get('firewall'), force=True) \
+ if payload.get('enabled') else (
+ {'success': True} if disabled_first else operation(payload.get('firewall'))
+ )
+ if not result.get('success'):
+ raise RuntimeError(result.get('error') or 'firewall state restore failed')
+
+ return {'success': True, 'rules_added': len(additions), 'rules_removed': len(removals)}
diff --git a/backend/app/services/restore_point_adapter_nginx.py b/backend/app/services/restore_point_adapter_nginx.py
new file mode 100644
index 00000000..0757d8d3
--- /dev/null
+++ b/backend/app/services/restore_point_adapter_nginx.py
@@ -0,0 +1,79 @@
+"""Restore-point adapter for one local nginx vhost lifecycle."""
+
+import os
+
+from app.services.nginx_service import NginxService
+
+
+def _validate_scope(scope_id, server_id):
+ name = str(scope_id or '')
+ if (
+ not name
+ or name in ('.', '..')
+ or os.path.isabs(name)
+ or os.path.basename(name) != name
+ or '/' in name
+ or '\\' in name
+ or '\x00' in name
+ ):
+ raise ValueError('nginx vhost scope must be one safe filename')
+ if server_id is not None:
+ raise ValueError('Remote nginx vhost restore points are not supported')
+ return name
+
+
+def capture(scope_id, server_id=None):
+ """Capture file existence, enablement, and exact vhost bytes.
+
+ A present-but-unreadable file is not represented as an empty or absent
+ vhost. Refusing that capture prevents a later restore from deleting state
+ that merely could not be observed.
+ """
+ name = _validate_scope(scope_id, server_id)
+ available_path = os.path.join(NginxService.SITES_AVAILABLE, name)
+ enabled_path = os.path.join(NginxService.SITES_ENABLED, name)
+ exists = os.path.exists(available_path)
+ content = NginxService.read_vhost(name) if exists else None
+ if exists and content is None:
+ raise RuntimeError(f'Existing nginx vhost {name} could not be read')
+ return {
+ 'exists': exists,
+ 'enabled': os.path.exists(enabled_path),
+ 'content': content,
+ }
+
+
+def _validate_payload(payload):
+ if not isinstance(payload, dict):
+ raise ValueError('nginx restore payload must be an object')
+ if not isinstance(payload.get('exists'), bool):
+ raise ValueError('nginx restore payload requires an exists flag')
+ if not isinstance(payload.get('enabled'), bool):
+ raise ValueError('nginx restore payload requires an enabled flag')
+ content = payload.get('content')
+ if payload['exists'] and not isinstance(content, str):
+ raise ValueError('Existing nginx restore payload requires vhost content')
+ return payload['exists'], payload['enabled'], content
+
+
+def restore(scope_id, payload, actor=None, server_id=None):
+ """Re-converge exclusively through nginx lifecycle service doors."""
+ del actor # Actor attribution belongs to the generic restore-point service.
+ name = _validate_scope(scope_id, server_id)
+ exists, enabled, content = _validate_payload(payload)
+
+ if not exists:
+ return NginxService.delete_site(name)
+
+ written = NginxService.write_vhost(name, content, enable=enabled)
+ if not written.get('success'):
+ return written
+
+ # write_vhost(enable=False) deliberately preserves a currently enabled
+ # site. A restore target is stronger: reproduce the captured enabled bit.
+ if not enabled:
+ disabled = NginxService.disable_site(name)
+ if not disabled.get('success'):
+ return disabled
+
+ return {'success': True, 'message': f'nginx vhost {name} restored'}
diff --git a/backend/app/services/restore_point_adapters.py b/backend/app/services/restore_point_adapters.py
new file mode 100644
index 00000000..43a49d01
--- /dev/null
+++ b/backend/app/services/restore_point_adapters.py
@@ -0,0 +1,29 @@
+"""Registration for the restore-point adapters shipped by core."""
+
+
+def register_builtin_restore_point_adapters():
+ """Register core surfaces on every app-factory invocation.
+
+ Registration is deliberately idempotent: tests and plugin reloads may
+ rebuild the Flask app in the same process, and replacing an adapter with
+ the same module is harmless.
+ """
+ from app.services import (
+ restore_point_adapter_cron,
+ restore_point_adapter_dns,
+ restore_point_adapter_env,
+ restore_point_adapter_firewall,
+ restore_point_adapter_nginx,
+ restore_point_service,
+ )
+
+ adapters = {
+ 'cron': restore_point_adapter_cron,
+ 'dns': restore_point_adapter_dns,
+ 'env': restore_point_adapter_env,
+ 'firewall': restore_point_adapter_firewall,
+ 'nginx_vhost': restore_point_adapter_nginx,
+ }
+ for scope_type, adapter in adapters.items():
+ restore_point_service.register_adapter(scope_type, adapter)
+ return adapters
diff --git a/backend/app/services/restore_point_service.py b/backend/app/services/restore_point_service.py
index 1687f55d..ce516bc6 100644
--- a/backend/app/services/restore_point_service.py
+++ b/backend/app/services/restore_point_service.py
@@ -47,8 +47,10 @@ BASE_COVERAGE = (
SCOPE_COVERAGE = {
'firewall': (
- "Rules added outside the panel (fail2ban runtime bans, Docker's "
- 'iptables chains) are not captured.',
+ 'Persisted panel-supported UFW rules and firewalld service, port, and '
+ 'rich-rule families are part of this checkpoint, including matching '
+ 'rules created outside the panel. Other firewalld families, interfaces, '
+ 'sources, and runtime-only fail2ban/Docker chains are not captured.',
),
'dns': (
'Records that exist only at the provider and were never managed by '
diff --git a/backend/app/services/site_domain_service.py b/backend/app/services/site_domain_service.py
index cddab812..4d767360 100644
--- a/backend/app/services/site_domain_service.py
+++ b/backend/app/services/site_domain_service.py
@@ -571,9 +571,6 @@ class SiteDomainService:
return {'nginx': None, 'warning': str(e)}
if not res.get('success'):
return {'nginx': res, 'warning': f"nginx vhost not created: {res.get('error')}"}
- en = NginxService.enable_site(app.name)
- if not en.get('success'):
- return {'nginx': res, 'warning': f"vhost written but not enabled: {en.get('error')}"}
return {'nginx': res, 'warning': None}
@classmethod
diff --git a/backend/migrations/versions/092_restore_point_adapter_ledgers.py b/backend/migrations/versions/092_restore_point_adapter_ledgers.py
new file mode 100644
index 00000000..61bca39b
--- /dev/null
+++ b/backend/migrations/versions/092_restore_point_adapter_ledgers.py
@@ -0,0 +1,71 @@
+"""Add restore-point replay metadata to environment and DNS ledgers.
+
+Revision ID: 092_restore_point_ledgers
+Revises: 091_restore_points
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = '092_restore_point_ledgers'
+down_revision = '091_restore_points'
+branch_labels = None
+depends_on = None
+
+
+def _has_column(table, column):
+ return column in {
+ item['name'] for item in sa.inspect(op.get_bind()).get_columns(table)
+ }
+
+
+def upgrade():
+ if not _has_column('environment_variable_history', 'batch_id'):
+ op.add_column(
+ 'environment_variable_history',
+ sa.Column('batch_id', sa.String(length=36), nullable=True),
+ )
+ op.create_index(
+ 'ix_environment_variable_history_batch_id',
+ 'environment_variable_history',
+ ['batch_id'],
+ )
+
+ if not _has_column('dns_changes', 'before_json'):
+ op.add_column(
+ 'dns_changes',
+ sa.Column('before_json', sa.Text(), nullable=True),
+ )
+
+ if not _has_column('managed_dns_records', 'ttl'):
+ op.add_column(
+ 'managed_dns_records',
+ sa.Column('ttl', sa.Integer(), nullable=True),
+ )
+ if not _has_column('managed_dns_records', 'priority'):
+ op.add_column(
+ 'managed_dns_records',
+ sa.Column('priority', sa.Integer(), nullable=True),
+ )
+ if not _has_column('managed_dns_records', 'proxied'):
+ op.add_column(
+ 'managed_dns_records',
+ sa.Column('proxied', sa.Boolean(), nullable=True),
+ )
+
+
+def downgrade():
+ if _has_column('managed_dns_records', 'proxied'):
+ op.drop_column('managed_dns_records', 'proxied')
+ if _has_column('managed_dns_records', 'priority'):
+ op.drop_column('managed_dns_records', 'priority')
+ if _has_column('managed_dns_records', 'ttl'):
+ op.drop_column('managed_dns_records', 'ttl')
+ if _has_column('dns_changes', 'before_json'):
+ op.drop_column('dns_changes', 'before_json')
+ if _has_column('environment_variable_history', 'batch_id'):
+ op.drop_index(
+ 'ix_environment_variable_history_batch_id',
+ table_name='environment_variable_history',
+ )
+ op.drop_column('environment_variable_history', 'batch_id')
diff --git a/backend/tests/api_controller_boundary_baseline.json b/backend/tests/api_controller_boundary_baseline.json
index 106cbf1e..2e264e84 100644
--- a/backend/tests/api_controller_boundary_baseline.json
+++ b/backend/tests/api_controller_boundary_baseline.json
@@ -3,7 +3,7 @@
"policy": "Exact reviewed inventory of direct persistence, subprocess, and filesystem mutation calls in Flask API controllers. New calls are forbidden; remove entries as controllers delegate to services.",
"counts": {
"filesystem": 11,
- "persistence": 504
+ "persistence": 503
},
"owners": {
"api/admin.py": {
@@ -533,7 +533,6 @@
"api/domains.py::verify_domain::persistence::Domain.query_active().filter_by(id=domain_id).first()::1",
"api/env_vars.py::check_app_access::persistence::Application.query_active().filter_by(id=app_id).first()::1",
"api/env_vars.py::check_app_access::persistence::User.query.get(user_id)::1",
- "api/env_vars.py::update_env_var::persistence::db.session.commit()::1",
"api/environments.py::_accessible_workspace_ids::persistence::Workspace.query.all()::1",
"api/environments.py::create_environment::persistence::db.session.commit()::1",
"api/files.py::upload_file::filesystem::os.makedirs(parent)::1",
diff --git a/backend/tests/test_dns_change_log.py b/backend/tests/test_dns_change_log.py
index 9330e5b3..0d70a42b 100644
--- a/backend/tests/test_dns_change_log.py
+++ b/backend/tests/test_dns_change_log.py
@@ -69,7 +69,8 @@ def test_failed_write_logs_error_and_notifies(app, monkeypatch):
def test_delete_is_logged(app):
from app.services.dns_ownership_service import DnsOwnershipService as O
from app.models.dns_change import DnsChange
- O.record_write('cloudflare', 'z1', 'A', 'www.example.com', provider_record_id='R1', source='zone')
+ O.record_write('cloudflare', 'z1', 'A', 'www.example.com',
+ provider_record_id='R1', source='zone', config_id=3)
O.guarded_delete(FakeClient(), provider_zone_id='z1', record_type='A',
name='www.example.com', provider_record_id='R1', source='zone', config_id=3)
row = DnsChange.query.filter_by(provider_zone_id='z1', action='delete').first()
diff --git a/backend/tests/test_dns_cloudflare_client.py b/backend/tests/test_dns_cloudflare_client.py
index 3c4e5875..8d11afd3 100644
--- a/backend/tests/test_dns_cloudflare_client.py
+++ b/backend/tests/test_dns_cloudflare_client.py
@@ -162,6 +162,19 @@ def test_delete_missing_is_success(monkeypatch):
assert res['success'] is True and 'already deleted' in res['message']
+def test_delete_stale_record_id_is_idempotent(monkeypatch):
+ from app.services.dns import cloudflare as cf
+ monkeypatch.setattr(
+ cf.requests, 'delete',
+ lambda *a, **k: _Resp({
+ 'success': False,
+ 'errors': [{'code': 81044, 'message': 'DNS record does not exist'}],
+ }),
+ )
+ res = _client().delete('z', record_id='stale')
+ assert res['success'] is True
+
+
# ── zone layer regression: capture provider_record_id on create ──────────────
def test_zone_create_record_persists_provider_record_id(app, monkeypatch):
diff --git a/backend/tests/test_dns_restore_points.py b/backend/tests/test_dns_restore_points.py
new file mode 100644
index 00000000..52cb2a27
--- /dev/null
+++ b/backend/tests/test_dns_restore_points.py
@@ -0,0 +1,655 @@
+"""Plan 81 M2: DNS guarded doors, complete ledger, and restore adapter."""
+import json
+
+import pytest
+
+
+class FakeRecordClient:
+ def __init__(self, records=None, *, delete_result=None):
+ self.records = records or {}
+ self.delete_result = delete_result
+ self.calls = []
+ self._next_id = 1
+
+ @staticmethod
+ def _key(record_type, name):
+ return record_type.upper(), name.lower().rstrip('.')
+
+ def list_records(self, zone_id):
+ return {'success': True, 'records': list(self.records.values())}
+
+ def find_record_id(self, zone_id, record_type, name, caa=None):
+ self.calls.append(('find', zone_id, record_type, name))
+ row = self.records.get(self._key(record_type, name))
+ return row.get('id') if row else None
+
+ def upsert(self, zone_id, spec, record_id=None):
+ self.calls.append(('upsert', zone_id, spec, record_id))
+ record_id = record_id or f'R{self._next_id}'
+ self._next_id += 1
+ self.records[self._key(spec.record_type, spec.name)] = {
+ 'id': record_id,
+ 'type': spec.record_type,
+ 'name': spec.name,
+ 'content': spec.content,
+ 'ttl': spec.ttl,
+ 'priority': spec.priority,
+ 'proxied': spec.proxied,
+ }
+ return {'success': True, 'record_id': record_id, 'message': 'set'}
+
+ def delete(self, zone_id, record_id=None, record_type=None, name=None):
+ self.calls.append(('delete', zone_id, record_id, record_type, name))
+ if self.delete_result is not None:
+ return self.delete_result
+ self.records.pop(self._key(record_type, name), None)
+ return {'success': True, 'message': 'deleted'}
+
+
+class RejectStaleIdClient(FakeRecordClient):
+ """Models Cloudflare/DO: PUT to a deleted record id fails with not-found."""
+
+ def upsert(self, zone_id, spec, record_id=None):
+ live_ids = {row.get('id') for row in self.records.values()}
+ if record_id is not None and record_id not in live_ids:
+ self.calls.append(('stale-upsert', zone_id, spec, record_id))
+ return {'success': False, 'error': 'record id not found'}
+ return super().upsert(zone_id, spec, record_id=record_id)
+
+
+def _config(db, provider):
+ from app.models.email import DNSProviderConfig
+ row = DNSProviderConfig(
+ name=f'{provider}-connection', provider=provider,
+ api_key='key', api_secret='secret',
+ )
+ db.session.add(row)
+ db.session.commit()
+ return row
+
+
+ 'provider', ['cloudflare', 'route53', 'digitalocean', 'godaddy'],
+)
+def test_provider_service_writes_all_providers_through_guarded_door(
+ app, monkeypatch, provider):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_service
+ from app.services.dns_provider_service import DNSProviderService
+
+ config = _config(db, provider)
+ client = FakeRecordClient()
+ scopes = []
+ monkeypatch.setattr(
+ DNSProviderService, 'record_client',
+ classmethod(lambda cls, cfg: client),
+ )
+ monkeypatch.setattr(
+ restore_point_service, 'auto_capture',
+ lambda scope_type, scope_id, action, **kwargs:
+ scopes.append((scope_type, scope_id, action)),
+ )
+
+ result = DNSProviderService.set_record(
+ config.id, 'zone-1', 'MX', 'example.com', 'mail.example.com',
+ ttl=120, priority=10, proxied=True,
+ )
+
+ assert result['success'] is True
+ row = ManagedDnsRecord.query.one()
+ assert (row.provider, row.dns_provider_config_id, row.provider_zone_id) == (
+ provider, config.id, 'zone-1',
+ )
+ assert (row.ttl, row.priority, row.proxied) == (120, 10, True)
+ assert scopes == [(
+ 'dns', f'{provider}:{config.id}:zone-1',
+ 'upsert MX example.com',
+ )]
+
+
+ 'provider', ['cloudflare', 'route53', 'digitalocean', 'godaddy'],
+)
+def test_supported_clients_share_record_contract(provider):
+ from app.services.dns import get_record_client
+ from app.services.dns.base import DnsCredential
+
+ client = get_record_client(DnsCredential(
+ provider=provider, token='key', secret='secret',
+ ))
+ assert all(callable(getattr(client, method)) for method in (
+ 'list_records', 'find_record_id', 'upsert', 'delete',
+ ))
+
+
+def test_rrset_ownership_is_scoped_by_provider_connection(app):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ first = _config(db, 'cloudflare')
+ second = _config(db, 'cloudflare')
+ O.record_write(
+ 'cloudflare', 'shared-zone-id', 'A', 'WWW.Example.com.',
+ provider_record_id='FIRST', content='1.1.1.1', config_id=first.id,
+ )
+ O.record_write(
+ 'cloudflare', 'shared-zone-id', 'A', 'www.example.com',
+ provider_record_id='SECOND', content='2.2.2.2', config_id=second.id,
+ )
+
+ assert ManagedDnsRecord.query.count() == 2
+ assert O.owns(
+ 'shared-zone-id', provider_record_id='FIRST',
+ provider='cloudflare', config_id=first.id,
+ )
+ assert not O.owns(
+ 'shared-zone-id', provider_record_id='FIRST',
+ provider='cloudflare', config_id=second.id,
+ )
+
+
+def test_change_log_keeps_complete_before_value(app, monkeypatch):
+ from app import db
+ from app.models.dns_change import DnsChange
+ from app.services import restore_point_service
+ from app.services.dns.base import DnsRecordSpec
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'cloudflare')
+ client = FakeRecordClient()
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+ O.guarded_upsert(
+ client, provider='cloudflare', provider_zone_id='zone',
+ spec=DnsRecordSpec('A', 'www.example.com', '1.1.1.1', 300,
+ priority=None, proxied=True),
+ source='zone', config_id=config.id,
+ )
+ O.guarded_upsert(
+ client, provider='cloudflare', provider_zone_id='zone',
+ spec=DnsRecordSpec('A', 'www.example.com', '2.2.2.2', 60,
+ priority=None, proxied=False),
+ source='zone', config_id=config.id,
+ )
+
+ change = DnsChange.query.filter_by(action='update').one()
+ assert json.loads(change.before_json) == {
+ 'app_id': None,
+ 'content': '1.1.1.1',
+ 'name': 'www.example.com',
+ 'priority': None,
+ 'proxied': True,
+ 'record_type': 'A',
+ 'source': 'zone',
+ 'ttl': 300,
+ }
+
+
+def test_guarded_door_canonicalizes_embedded_mx_priority(app, monkeypatch):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_service
+ from app.services.dns.base import DnsRecordSpec
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'route53')
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+ O.guarded_upsert(
+ FakeRecordClient(), provider='route53', provider_zone_id='zone',
+ spec=DnsRecordSpec('MX', 'example.com', '10 mail.example.com', 300),
+ source='email', config_id=config.id,
+ )
+
+ row = ManagedDnsRecord.query.one()
+ assert row.content == 'mail.example.com'
+ assert row.priority == 10
+
+
+def test_failed_delete_keeps_ownership_and_logs_preimage(app, monkeypatch):
+ from app import db
+ from app.models.dns_change import DnsChange
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_service
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'digitalocean')
+ O.record_write(
+ 'digitalocean', 'example.com', 'MX', 'example.com',
+ provider_record_id='77', content='mail.example.com', ttl=600,
+ priority=10, proxied=False, source='email', config_id=config.id,
+ )
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+ result = O.guarded_delete(
+ FakeRecordClient(delete_result={'success': False, 'error': 'timeout'}),
+ provider='digitalocean', provider_zone_id='example.com',
+ record_type='MX', name='example.com', provider_record_id='77',
+ source='email', config_id=config.id,
+ )
+
+ assert result['success'] is False
+ assert ManagedDnsRecord.query.filter_by(provider_record_id='77').one()
+ change = DnsChange.query.filter_by(action='delete').one()
+ assert change.result == 'error'
+ assert json.loads(change.before_json)['priority'] == 10
+
+
+def test_dns_capture_reads_managed_ledger_not_zone_mirror(app):
+ from app import db
+ from app.models.dns_zone import DNSRecord, DNSZone
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+ from app.services.restore_point_adapter_dns import capture
+
+ config = _config(db, 'cloudflare')
+ zone = DNSZone(
+ domain='example.com', provider='cloudflare', provider_zone_id='zone',
+ dns_provider_config_id=config.id,
+ )
+ db.session.add(zone)
+ db.session.flush()
+ db.session.add(DNSRecord(
+ zone_id=zone.id, record_type='A', name='foreign.example.com',
+ content='9.9.9.9', ttl=60,
+ ))
+ db.session.commit()
+
+ scope = f'cloudflare:{config.id}:zone'
+ assert capture(scope)['records'] == []
+
+ O.record_write(
+ 'cloudflare', 'zone', 'A', 'owned.example.com',
+ provider_record_id='OWNED', content='1.2.3.4', ttl=120,
+ priority=None, proxied=True, source='zone', config_id=config.id,
+ )
+ payload = capture(scope)
+ assert [row['name'] for row in payload['records']] == ['owned.example.com']
+ assert payload['records'][0]['ttl'] == 120
+ assert payload['records'][0]['proxied'] is True
+
+
+def test_dns_restore_round_trip_uses_guarded_calls(app, monkeypatch):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services import restore_point_service
+ from app.services.dns.base import DnsRecordSpec
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'cloudflare')
+ client = FakeRecordClient()
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'cloudflare:{config.id}:zone'
+
+ O.guarded_upsert(
+ client, provider='cloudflare', provider_zone_id='zone',
+ spec=DnsRecordSpec('A', 'www.example.com', '1.1.1.1', 300,
+ proxied=True),
+ source='zone', config_id=config.id,
+ )
+ checkpoint = adapter.capture(scope)
+ O.guarded_upsert(
+ client, provider='cloudflare', provider_zone_id='zone',
+ spec=DnsRecordSpec('A', 'www.example.com', '2.2.2.2', 60),
+ source='zone', config_id=config.id,
+ )
+ O.guarded_upsert(
+ client, provider='cloudflare', provider_zone_id='zone',
+ spec=DnsRecordSpec('TXT', 'extra.example.com', 'remove-me', 60),
+ source='zone', config_id=config.id,
+ )
+
+ result = adapter.restore(scope, checkpoint)
+ assert result['success'] is True
+ rows = ManagedDnsRecord.query.order_by(ManagedDnsRecord.record_type).all()
+ assert [(row.record_type, row.content) for row in rows] == [
+ ('A', '1.1.1.1'),
+ ]
+ assert rows[0].ttl == 300 and rows[0].proxied is True
+ assert ('TXT', 'extra.example.com') not in client.records
+
+
+def test_dns_restore_refuses_provider_only_target(app, monkeypatch):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+
+ config = _config(db, 'cloudflare')
+ client = FakeRecordClient(records={
+ ('A', 'foreign.example.com'): {
+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',
+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,
+ 'proxied': False,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'cloudflare:{config.id}:zone'
+ payload = {
+ 'provider': 'cloudflare',
+ 'config_id': config.id,
+ 'provider_zone_id': 'zone',
+ 'records': [{
+ 'record_type': 'A', 'name': 'foreign.example.com',
+ 'content': '1.2.3.4', 'ttl': 60, 'priority': None,
+ 'proxied': False, 'source': 'restore', 'app_id': None,
+ }],
+ }
+
+ result = adapter.restore(scope, payload)
+ assert result['success'] is False and result['conflict'] is True
+ assert not any(call[0] == 'upsert' for call in client.calls)
+ assert client.records[('A', 'foreign.example.com')]['content'] == '9.9.9.9'
+
+
+def test_dns_validate_restore_surfaces_foreign_conflict(app, monkeypatch):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+
+ config = _config(db, 'cloudflare')
+ client = FakeRecordClient(records={
+ ('A', 'foreign.example.com'): {
+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',
+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,
+ 'proxied': False,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'cloudflare:{config.id}:zone'
+ payload = {
+ 'provider': 'cloudflare', 'config_id': config.id,
+ 'provider_zone_id': 'zone',
+ 'records': [{
+ 'record_type': 'A', 'name': 'foreign.example.com',
+ 'content': '1.2.3.4', 'ttl': 60, 'priority': None,
+ 'proxied': False, 'source': 'restore', 'app_id': None,
+ }],
+ }
+
+ refusals = adapter.validate_restore(scope, payload, {'records': []})
+ assert len(refusals) == 1
+ assert 'provider-only DNS record A foreign.example.com' in refusals[0]
+
+
+def test_restore_point_preview_disables_foreign_dns_restore(app, monkeypatch):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services import restore_point_service as service
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'cloudflare')
+ scope = f'cloudflare:{config.id}:zone'
+ O.record_write(
+ 'cloudflare', 'zone', 'A', 'foreign.example.com',
+ provider_record_id='FORMERLY-OURS', content='1.2.3.4', ttl=60,
+ source='zone', config_id=config.id,
+ )
+ monkeypatch.setitem(service.ADAPTERS, 'dns', adapter)
+ point = service.capture('dns', scope, 'manual')
+ O.record_delete(
+ 'zone', provider_record_id='FORMERLY-OURS', provider='cloudflare',
+ config_id=config.id,
+ )
+
+ client = FakeRecordClient(records={
+ ('A', 'foreign.example.com'): {
+ 'id': 'FOREIGN', 'type': 'A', 'name': 'foreign.example.com',
+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,
+ 'proxied': False,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+
+ preview = service.preview(point.id)
+ assert preview['can_restore'] is False
+ assert 'provider-only DNS record' in preview['refusals'][0]
+
+
+def test_dns_restore_repairs_provider_when_ledger_already_matches(app, monkeypatch):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services import restore_point_service
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'cloudflare')
+ client = RejectStaleIdClient() # provider record drifted away / was deleted
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'cloudflare:{config.id}:zone'
+ O.record_write(
+ 'cloudflare', 'zone', 'A', 'www.example.com',
+ provider_record_id='STALE', content='1.1.1.1', ttl=300,
+ proxied=True, source='zone', config_id=config.id,
+ )
+ checkpoint = adapter.capture(scope)
+
+ result = adapter.restore(scope, checkpoint)
+ assert result['success'] is True
+ assert any(call[0] == 'upsert' for call in client.calls)
+ assert not any(call[0] == 'stale-upsert' for call in client.calls)
+ assert client.records[('A', 'www.example.com')]['content'] == '1.1.1.1'
+
+
+def test_legacy_dns_attributes_remain_unknown_and_restore_refuses_to_guess(
+ app, monkeypatch):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_adapter_dns as adapter
+
+ config = _config(db, 'cloudflare')
+ db.session.add(ManagedDnsRecord(
+ provider='cloudflare', dns_provider_config_id=config.id,
+ provider_zone_id='zone', provider_record_id='OLD',
+ record_type='A', name='legacy.example.com', content='1.2.3.4',
+ ttl=None, priority=None, proxied=None, source='zone',
+ ))
+ db.session.commit()
+ scope = f'cloudflare:{config.id}:zone'
+ payload = adapter.capture(scope)
+ record = payload['records'][0]
+ assert record['ttl'] is None
+ assert record['priority'] is None
+ assert record['proxied'] is None
+
+ client = FakeRecordClient() # live record is also gone; no safe hydration
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ refusals = adapter.validate_restore(scope, payload, payload)
+ assert any('unknown legacy TTL' in refusal for refusal in refusals)
+ assert any('unknown legacy proxy state' in refusal for refusal in refusals)
+
+ result = adapter.restore(scope, payload)
+ assert result['success'] is False and result['refused'] is True
+ assert not any(call[0] == 'upsert' for call in client.calls)
+
+
+def test_legacy_dns_attributes_hydrate_from_live_provider(app, monkeypatch):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services import restore_point_service
+
+ config = _config(db, 'cloudflare')
+ db.session.add(ManagedDnsRecord(
+ provider='cloudflare', dns_provider_config_id=config.id,
+ provider_zone_id='zone', provider_record_id='OLD',
+ record_type='A', name='legacy.example.com', content='1.2.3.4',
+ ttl=None, priority=None, proxied=None, source='zone',
+ ))
+ db.session.commit()
+ scope = f'cloudflare:{config.id}:zone'
+ payload = adapter.capture(scope)
+ client = FakeRecordClient(records={
+ ('A', 'legacy.example.com'): {
+ 'id': 'OLD', 'type': 'A', 'name': 'legacy.example.com',
+ 'content': '9.9.9.9', 'ttl': 120, 'priority': None,
+ 'proxied': True,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ monkeypatch.setattr(restore_point_service, 'auto_capture', lambda *a, **k: None)
+
+ assert adapter.validate_restore(scope, payload, payload) == []
+ result = adapter.restore(scope, payload)
+ assert result['success'] is True
+ row = ManagedDnsRecord.query.one()
+ assert row.ttl == 120 and row.proxied is True
+ live = client.records[('A', 'legacy.example.com')]
+ assert live['content'] == '1.2.3.4'
+ assert live['ttl'] == 120 and live['proxied'] is True
+
+
[email protected]('provider', ['route53', 'godaddy'])
+def test_dns_restore_refuses_delete_of_synthetic_id_replacement(
+ app, monkeypatch, provider):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, provider)
+ zone_id = 'zone'
+ synthetic_id = 'A:old.example.com'
+ O.record_write(
+ provider, zone_id, 'A', 'old.example.com',
+ provider_record_id=synthetic_id, content='1.1.1.1', ttl=300,
+ proxied=False, source='zone', config_id=config.id,
+ )
+ client = FakeRecordClient(records={
+ ('A', 'old.example.com'): {
+ 'id': synthetic_id, 'type': 'A', 'name': 'old.example.com',
+ 'content': '9.9.9.9', 'ttl': 300, 'priority': None,
+ 'proxied': False,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'{provider}:{config.id}:{zone_id}'
+ empty_target = {
+ 'provider': provider, 'config_id': config.id,
+ 'provider_zone_id': zone_id, 'records': [],
+ }
+
+ refusals = adapter.validate_restore(scope, empty_target, empty_target)
+ assert any('provider-only replacement' in item for item in refusals)
+ result = adapter.restore(scope, empty_target)
+ assert result['success'] is False and result['refused'] is True
+ assert not any(call[0] == 'delete' for call in client.calls)
+
+
+def test_synthetic_mx_encoded_priority_is_same_owned_record(app, monkeypatch):
+ from app import db
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'route53')
+ O.record_write(
+ 'route53', 'zone', 'MX', 'example.com',
+ provider_record_id='MX:example.com', content='10 mail.example.com.',
+ ttl=300, priority=None, proxied=False, source='legacy',
+ config_id=config.id,
+ )
+ client = FakeRecordClient(records={
+ ('MX', 'example.com'): {
+ 'id': 'MX:example.com', 'type': 'MX', 'name': 'example.com',
+ 'content': 'mail.example.com', 'ttl': 300, 'priority': 10,
+ 'proxied': False,
+ },
+ })
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'route53:{config.id}:zone'
+ empty_target = {
+ 'provider': 'route53', 'config_id': config.id,
+ 'provider_zone_id': 'zone', 'records': [],
+ }
+
+ assert adapter.validate_restore(scope, empty_target, empty_target) == []
+ result = adapter.restore(scope, empty_target)
+ assert result['success'] is True
+ assert any(call[0] == 'delete' for call in client.calls)
+
+
+def test_dns_restore_forgets_stale_ledger_when_provider_already_absent(
+ app, monkeypatch):
+ from app import db
+ from app.models.managed_dns_record import ManagedDnsRecord
+ from app.services import restore_point_adapter_dns as adapter
+ from app.services.dns_ownership_service import DnsOwnershipService as O
+
+ config = _config(db, 'cloudflare')
+ O.record_write(
+ 'cloudflare', 'zone', 'A', 'gone.example.com',
+ provider_record_id='STALE', content='1.1.1.1', ttl=300,
+ proxied=False, source='zone', config_id=config.id,
+ )
+ client = FakeRecordClient() # compliant delete treats missing id as success
+ monkeypatch.setattr(adapter, '_client_for_scope', lambda *args: client)
+ scope = f'cloudflare:{config.id}:zone'
+ empty_target = {
+ 'provider': 'cloudflare', 'config_id': config.id,
+ 'provider_zone_id': 'zone', 'records': [],
+ }
+
+ result = adapter.restore(scope, empty_target)
+ assert result['success'] is True
+ assert ManagedDnsRecord.query.count() == 0
+
+
+def test_digitalocean_delete_stale_record_id_is_idempotent(monkeypatch):
+ from app.services.dns.base import DnsCredential
+ from app.services.dns.providers import DigitalOceanClient
+ from app.services.dns import providers
+
+ class MissingResponse:
+ status_code = 404
+
+ @staticmethod
+ def json():
+ return {'id': 'not_found', 'message': 'record not found'}
+
+ monkeypatch.setattr(
+ providers.requests, 'delete', lambda *a, **k: MissingResponse(),
+ )
+ client = DigitalOceanClient(DnsCredential(
+ provider='digitalocean', token='token',
+ ))
+ result = client.delete('example.com', record_id='stale')
+ assert result['success'] is True
+
+
[email protected]('provider', ['route53', 'godaddy'])
+def test_rrset_providers_detect_different_caa_as_existing(monkeypatch, provider):
+ """A typed RRset PUT would replace other values, so strict guards must see it."""
+ from app.services.dns.base import DnsCredential
+ from app.services.dns.providers import GoDaddyClient, Route53Client
+ from app.services.dns import providers
+
+ caa = {'flags': 0, 'tag': 'issue', 'value': 'letsencrypt.org'}
+ if provider == 'route53':
+ class FakeBoto:
+ @staticmethod
+ def list_resource_record_sets(**kwargs):
+ return {'ResourceRecordSets': [{
+ 'Name': 'example.com.', 'Type': 'CAA', 'TTL': 300,
+ 'ResourceRecords': [{'Value': '0 issue "digicert.com"'}],
+ }]}
+
+ client = Route53Client(
+ DnsCredential(provider='route53'), client=FakeBoto(),
+ )
+ else:
+ class Response:
+ status_code = 200
+
+ @staticmethod
+ def json():
+ return [{
+ 'type': 'CAA', 'name': '@', 'data': 'digicert.com',
+ 'flags': 0, 'tag': 'issue', 'ttl': 300,
+ }]
+
+ monkeypatch.setattr(
+ providers.requests, 'get', lambda *a, **k: Response(),
+ )
+ client = GoDaddyClient(DnsCredential(
+ provider='godaddy', token='key', secret='secret',
+ ))
+
+ assert client.find_record_id(
+ 'example.com', 'CAA', 'example.com', caa=caa,
+ ) is not None
diff --git a/backend/tests/test_restore_point_adapters.py b/backend/tests/test_restore_point_adapters.py
new file mode 100644
index 00000000..439f60f5
--- /dev/null
+++ b/backend/tests/test_restore_point_adapters.py
@@ -0,0 +1,10 @@
+"""Core restore-point adapter registration contract."""
+
+
+def test_app_factory_registers_every_builtin_restore_surface(app):
+ from app.services.restore_point_service import get_adapter
+
+ assert {
+ scope for scope in ('cron', 'dns', 'env', 'firewall', 'nginx_vhost')
+ if get_adapter(scope) is not None
+ } == {'cron', 'dns', 'env', 'firewall', 'nginx_vhost'}
diff --git a/backend/tests/test_restore_point_cron.py b/backend/tests/test_restore_point_cron.py
new file mode 100644
index 00000000..c6ee6e38
--- /dev/null
+++ b/backend/tests/test_restore_point_cron.py
@@ -0,0 +1,181 @@
+"""Plan 81 M2: local CRON restore-point payloads and service hooks."""
+
+from copy import deepcopy
+
+import pytest
+
+from app.services.cron_service import CronService
+from app.services import restore_point_adapter_cron as adapter
+
+
+def cron_state(tmp_path, monkeypatch):
+ import app.services.cron_service as module
+
+ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))
+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: True))
+ state = {'crontab': '# hand-written\n0 1 * * * /usr/bin/original\n'}
+ monkeypatch.setattr(
+ CronService, '_read_crontab',
+ classmethod(lambda cls: state['crontab']),
+ )
+
+ def install(cls, content):
+ state['crontab'] = content
+ return None
+
+ monkeypatch.setattr(CronService, '_install_crontab', classmethod(install))
+ CronService._save_jobs_metadata({'jobs': {
+ 'job_1': {
+ 'name': 'Original',
+ 'schedule': '0 1 * * *',
+ 'command': '/usr/bin/original',
+ 'enabled': True,
+ 'tracked': False,
+ 'application_id': 7,
+ },
+ }})
+ return state
+
+
+def test_capture_contains_full_crontab_and_metadata(cron_state):
+ payload = adapter.capture('cron')
+
+ assert payload['crontab'] == cron_state['crontab']
+ assert payload['metadata']['jobs']['job_1']['application_id'] == 7
+
+
+def test_capture_fails_when_linux_crontab_is_unreadable(cron_state, monkeypatch):
+ monkeypatch.setattr(
+ CronService, '_read_crontab', classmethod(lambda cls: None),
+ )
+
+ with pytest.raises(RuntimeError, match='Could not read'):
+ adapter.capture('cron')
+
+
+def test_capture_fails_when_metadata_is_corrupt(cron_state, monkeypatch):
+ import app.services.cron_service as module
+
+ with open(module.JOBS_FILE, 'w') as handle:
+ handle.write('{not-json')
+
+ with pytest.raises(RuntimeError, match='metadata is unreadable'):
+ adapter.capture('cron')
+
+
+def test_restore_round_trip_reconverges_both_components(cron_state):
+ saved = adapter.capture('cron')
+ cron_state['crontab'] = '*/5 * * * * /usr/bin/changed\n'
+ CronService._save_jobs_metadata({'jobs': {
+ 'changed': {'schedule': '*/5 * * * *', 'command': '/usr/bin/changed'},
+ }})
+
+ result = adapter.restore('cron', saved)
+
+ assert result['success'] is True
+ assert adapter.capture('cron') == saved
+
+
+def test_restore_rolls_crontab_back_when_metadata_write_fails(
+ cron_state, monkeypatch):
+ target = {
+ 'crontab': '0 4 * * * /usr/bin/target\n',
+ 'metadata': {'jobs': {'target': {'command': '/usr/bin/target'}}},
+ }
+ before = adapter.capture('cron')
+ real_save = CronService._save_jobs_metadata.__func__
+ writes = []
+
+ def fail_target_once(cls, metadata):
+ writes.append(deepcopy(metadata))
+ if len(writes) == 1:
+ raise OSError('disk full')
+ return real_save(cls, metadata)
+
+ monkeypatch.setattr(
+ CronService, '_save_jobs_metadata', classmethod(fail_target_once),
+ )
+
+ result = adapter.restore('cron', target)
+
+ assert result['success'] is False
+ assert result['rolled_back'] is True
+ assert cron_state['crontab'] == before['crontab']
+ assert CronService._load_jobs_metadata() == before['metadata']
+
+
+def test_metadata_only_mutators_checkpoint_and_alert_flag_is_in_service(
+ app, tmp_path, monkeypatch):
+ import app.services.cron_service as module
+ from app.services import restore_point_service
+
+ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))
+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: False))
+ existing = restore_point_service.get_adapter('cron')
+ restore_point_service.register_adapter('cron', adapter)
+ captured = []
+ monkeypatch.setattr(
+ restore_point_service, 'capture',
+ lambda *args, **kwargs: captured.append((args, kwargs)),
+ )
+
+ try:
+ created = CronService.add_job(
+ '0 0 * * *', '/usr/bin/task', application_id=9,
+ )
+ job_id = created['job_id']
+ CronService.update_job(job_id, description='metadata only')
+ CronService.set_tracking(job_id, True, alert_on_failure=False)
+ assert CronService.get_job(job_id)['alert_on_failure'] is False
+ CronService.toggle_job(job_id, False)
+ CronService.remove_job(job_id)
+ finally:
+ if existing is None:
+ restore_point_service.ADAPTERS.pop('cron', None)
+ else:
+ restore_point_service.register_adapter('cron', existing)
+
+ actions = [item[1]['label'] for item in captured]
+ assert actions == [
+ 'before cron.add_job',
+ 'before cron.update_job',
+ 'before cron.set_tracking',
+ 'before cron.toggle_job',
+ 'before cron.remove_job',
+ ]
+
+
+def test_application_bulk_suspend_captures_once(app, tmp_path, monkeypatch):
+ import app.services.cron_service as module
+ from app.services import restore_point_service
+
+ monkeypatch.setattr(module, 'JOBS_FILE', str(tmp_path / 'cron_jobs.json'))
+ monkeypatch.setattr(CronService, 'is_linux', classmethod(lambda cls: False))
+ CronService._save_jobs_metadata({'jobs': {
+ 'one': {'application_id': 4, 'enabled': True},
+ 'two': {'application_id': 4, 'enabled': True},
+ }})
+ existing = restore_point_service.get_adapter('cron')
+ restore_point_service.register_adapter('cron', adapter)
+ captured = []
+ monkeypatch.setattr(
+ restore_point_service, 'capture',
+ lambda *args, **kwargs: captured.append((args, kwargs)),
+ )
+
+ try:
+ assert CronService.suspend_for_application(4) == 2
+ assert CronService.resume_for_application(4) == 2
+ assert CronService.clear_application(4) == 2
+ finally:
+ if existing is None:
+ restore_point_service.ADAPTERS.pop('cron', None)
+ else:
+ restore_point_service.register_adapter('cron', existing)
+
+ assert [item[1]['label'] for item in captured] == [
+ 'before cron.suspend_for_application',
+ 'before cron.resume_for_application',
+ 'before cron.clear_application',
+ ]
diff --git a/backend/tests/test_restore_point_env.py b/backend/tests/test_restore_point_env.py
new file mode 100644
index 00000000..4bc05d94
--- /dev/null
+++ b/backend/tests/test_restore_point_env.py
@@ -0,0 +1,260 @@
+"""Plan 81 M2: environment restore-point adapter and mutation doors."""
+
+import json
+
+import pytest
+
+from app.models import EnvironmentVariableHistory, RestorePoint
+from app.services import restore_point_adapter_env as env_adapter
+from app.utils.sensitive_data_filter import MASK
+
+
+def registered_env_adapter():
+ from app.services import restore_point_service
+
+ existing = dict(restore_point_service.ADAPTERS)
+ restore_point_service.register_adapter('env', env_adapter)
+ try:
+ yield restore_point_service
+ finally:
+ restore_point_service.clear_adapters()
+ restore_point_service.ADAPTERS.update(existing)
+
+
+def _make_app():
+ from app import db
+ from app.models import Application, User
+
+ user = User(
+ username='restore-env-owner',
+ role='admin',
+ )
+ db.session.add(user)
+ db.session.flush()
+ application = Application(
+ name='restore-env-app',
+ app_type='docker',
+ user_id=user.id,
+ status='running',
+ )
+ db.session.add(application)
+ db.session.commit()
+ return application, user
+
+
+def test_capture_masks_flags_sensitive_names_and_keeps_reference_metadata(
+ app, registered_env_adapter):
+ from app.services.env_service import EnvService
+
+ application, user = _make_app()
+ EnvService.set_env_var(
+ application.id, 'PUBLIC_URL', 'https://example.test', user_id=user.id,
+ )
+ EnvService.set_env_var(
+ application.id, 'API_TOKEN', 'raw-token', is_secret=False,
+ user_id=user.id,
+ )
+ EnvService.set_env_var(
+ application.id, 'INTERNAL', 'raw-secret', is_secret=True,
+ user_id=user.id,
+ )
+ reference = {'kind': 'secret', 'secret': 'stripe_prod'}
+ EnvService.set_env_reference(
+ application.id, 'STRIPE_KEY', reference, user.id,
+ target_service='web', description='Stripe credential',
+ )
+
+ point = registered_env_adapter.capture(
+ 'env', application.id, 'manual', label='mask-proof', actor=user.id,
+ )
+ payload = json.loads(point.payload_json)
+ assert payload['env']['PUBLIC_URL']['value'] == 'https://example.test'
+ assert payload['env']['API_TOKEN']['value'] == MASK
+ assert payload['env']['INTERNAL']['value'] == MASK
+ assert payload['env']['STRIPE_KEY'] == {
+ 'value': MASK,
+ 'is_secret': True,
+ 'description': 'Stripe credential',
+ 'target_service': 'web',
+ 'value_from': reference,
+ }
+ serialized = json.dumps(payload)
+ assert 'raw-token' not in serialized
+ assert 'raw-secret' not in serialized
+
+
+def test_every_env_mutation_door_auto_captures_once(
+ app, monkeypatch, registered_env_adapter):
+ from app.services import restore_point_service
+ from app.services.env_service import EnvService
+
+ application, user = _make_app()
+ captures = []
+
+ def fake_capture(scope_type, scope_id, trigger, **kwargs):
+ captures.append((scope_type, scope_id, trigger, kwargs.get('label')))
+ return object()
+
+ monkeypatch.setattr(restore_point_service, 'capture', fake_capture)
+
+ first, _, _ = EnvService.set_env_var(
+ application.id, 'FIRST', '1', user_id=user.id,
+ )
+ EnvService.update_env_var(
+ application.id, 'FIRST', value='2', user_id=user.id,
+ )
+ EnvService.set_env_reference(
+ application.id, 'REF', {'kind': 'secret', 'secret': 'one'}, user.id,
+ )
+ EnvService.delete_env_var(application.id, 'REF', user.id)
+ EnvService.delete_env_var_by_id(first.id, user.id)
+ EnvService.bulk_set_env_vars(
+ application.id, {'SECOND': '2', 'THIRD': '3'}, user.id,
+ )
+ EnvService.clear_all(application.id, user.id)
+
+ assert [item[3] for item in captures] == [
+ 'before env.set_env_var',
+ 'before env.update_env_var',
+ 'before env.set_env_reference',
+ 'before env.delete_env_var',
+ 'before env.delete_env_var_by_id',
+ 'before env.bulk_set_env_vars',
+ 'before env.clear_all',
+ ]
+ assert all(item[:3] == (
+ 'env', str(application.id), 'pre_mutation',
+ ) for item in captures)
+
+
+def test_bulk_and_clear_history_rows_share_operation_batch(
+ app, registered_env_adapter):
+ from app.services.env_service import EnvService
+
+ application, user = _make_app()
+ EnvService.bulk_set_env_vars(
+ application.id, {'ONE': '1', 'TWO': '2'}, user.id,
+ )
+
+ created = EnvironmentVariableHistory.query.filter_by(
+ application_id=application.id,
+ action='created',
+ ).order_by(EnvironmentVariableHistory.id).all()
+ assert len(created) == 2
+ assert created[0].batch_id
+ assert {row.batch_id for row in created} == {created[0].batch_id}
+
+ EnvService.clear_all(application.id, user.id)
+ deleted = EnvironmentVariableHistory.query.filter_by(
+ application_id=application.id,
+ action='deleted',
+ ).order_by(EnvironmentVariableHistory.id).all()
+ assert len(deleted) == 2
+ assert deleted[0].batch_id
+ assert {row.batch_id for row in deleted} == {deleted[0].batch_id}
+ assert deleted[0].batch_id != created[0].batch_id
+ assert all(row.to_dict()['batch_id'] == row.batch_id for row in deleted)
+
+
+def test_restore_round_trip_reconverges_and_groups_history(
+ app, registered_env_adapter):
+ from app.services.env_service import EnvService
+
+ application, user = _make_app()
+ EnvService.set_env_var(
+ application.id, 'FEATURE_FLAG', 'on', user_id=user.id,
+ )
+ point = registered_env_adapter.capture(
+ 'env', application.id, 'manual', label='known-good', actor=user.id,
+ )
+
+ EnvService.set_env_var(
+ application.id, 'FEATURE_FLAG', 'off', user_id=user.id,
+ )
+ EnvService.set_env_var(
+ application.id, 'TEMPORARY', 'remove-me', user_id=user.id,
+ )
+ points_before_restore = RestorePoint.query.filter_by(
+ scope_type='env', scope_id=str(application.id),
+ ).count()
+
+ result = registered_env_adapter.restore(point.id, actor=user)
+
+ assert result['success'] is True
+ assert EnvService.get_env_var(application.id, 'FEATURE_FLAG').value == 'on'
+ assert EnvService.get_env_var(application.id, 'TEMPORARY') is None
+ assert RestorePoint.query.filter_by(
+ scope_type='env', scope_id=str(application.id),
+ ).count() == points_before_restore + 1
+
+ replay_rows = EnvironmentVariableHistory.query.filter_by(
+ application_id=application.id,
+ batch_id=result['batch_id'],
+ ).all()
+ assert {row.key for row in replay_rows} == {'FEATURE_FLAG', 'TEMPORARY'}
+ assert {row.batch_id for row in replay_rows} == {result['batch_id']}
+
+
+def test_restore_keeps_live_masked_values_and_replays_references(
+ app, registered_env_adapter):
+ from app.services.env_service import EnvService
+
+ application, user = _make_app()
+ EnvService.set_env_var(
+ application.id, 'API_TOKEN', 'old-token', is_secret=True,
+ user_id=user.id,
+ )
+ original_reference = {'kind': 'secret', 'secret': 'stripe_old'}
+ EnvService.set_env_reference(
+ application.id, 'STRIPE_KEY', original_reference, user.id,
+ )
+ point = registered_env_adapter.capture(
+ 'env', application.id, 'manual', label='with-secrets', actor=user.id,
+ )
+
+ EnvService.set_env_var(
+ application.id, 'API_TOKEN', 'rotated-token', is_secret=True,
+ user_id=user.id,
+ )
+ EnvService.set_env_reference(
+ application.id, 'STRIPE_KEY',
+ {'kind': 'secret', 'secret': 'stripe_new'}, user.id,
+ )
+ EnvService.set_env_reference(
+ application.id, 'LIVE_ONLY_REF',
+ {'kind': 'secret', 'secret': 'keep_me'}, user.id,
+ )
+
+ result = registered_env_adapter.restore(point.id, actor=user)
+
+ token = EnvService.get_env_var(application.id, 'API_TOKEN')
+ stripe = EnvService.get_env_var(application.id, 'STRIPE_KEY')
+ live_only = EnvService.get_env_var(application.id, 'LIVE_ONLY_REF')
+ assert token.value == 'rotated-token'
+ assert stripe.get_reference() == original_reference
+ assert live_only.get_reference() == {
+ 'kind': 'secret', 'secret': 'keep_me',
+ }
+ assert 'API_TOKEN' in result['skipped_secrets']
+ assert 'LIVE_ONLY_REF' in result['preserved_references']
+ assert MASK not in {token.value, stripe.value, live_only.value}
+
+
+def test_env_diff_is_secret_safe_and_key_granular():
+ old = {'env': {
+ 'TOKEN': {'value': MASK, 'is_secret': True},
+ 'FLAG': {'value': 'on', 'is_secret': False},
+ }}
+ new = {'env': {
+ 'TOKEN': {'value': MASK, 'is_secret': True},
+ 'FLAG': {'value': 'off', 'is_secret': False},
+ 'ADDED': {'value': 'yes', 'is_secret': False},
+ }}
+
+ result = env_adapter.diff(old, new)
+ assert set(result['added']) == {'ADDED'}
+ assert set(result['changed']) == {'FLAG'}
+ assert result['removed'] == {}
+ assert 'TOKEN' not in result['changed']
diff --git a/backend/tests/test_restore_point_firewall.py b/backend/tests/test_restore_point_firewall.py
new file mode 100644
index 00000000..ad8189c8
--- /dev/null
+++ b/backend/tests/test_restore_point_firewall.py
@@ -0,0 +1,206 @@
+"""Plan 81 firewall checkpoint adapter and mutation-door coverage."""
+
+from types import SimpleNamespace
+
+import pytest
+
+
+def _ufw_payload(*, enabled=True, allow_default=False, rules=None):
+ return {
+ 'version': 1,
+ 'firewall': 'ufw',
+ 'enabled': enabled,
+ 'default_zone': None,
+ 'default_incoming_allow': allow_default,
+ 'rules': rules or [],
+ }
+
+
+def test_capture_uses_replayable_ufw_rules(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(
+ lambda cls: {
+ 'active_firewall': 'ufw',
+ 'ufw': {'installed': True, 'active': False},
+ 'firewalld': {'installed': False, 'running': False},
+ }))
+ monkeypatch.setattr(
+ adapter.FirewallService, '_ufw_default_incoming_policy',
+ classmethod(lambda cls: False),
+ )
+ monkeypatch.setattr(adapter, 'run_privileged', lambda argv, timeout=None: SimpleNamespace(
+ returncode=0,
+ stdout=('Added user rules\n'
+ 'ufw deny from 203.0.113.9\n'
+ 'ufw allow 2222/tcp\n'),
+ stderr='',
+ ))
+
+ payload = adapter.capture('firewall')
+
+ assert payload['enabled'] is False
+ assert payload['default_incoming_allow'] is False
+ assert payload['rules'] == sorted([
+ {'kind': 'ufw', 'argv': ['deny', 'from', '203.0.113.9']},
+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},
+ ], key=adapter._rule_key)
+
+
+def test_capture_refuses_unknown_ufw_policy_and_remote_scope(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(
+ lambda cls: {
+ 'active_firewall': 'ufw',
+ 'ufw': {'installed': True, 'active': False},
+ 'firewalld': {'installed': False, 'running': False},
+ }))
+ monkeypatch.setattr(
+ adapter.FirewallService, '_ufw_default_incoming_policy',
+ classmethod(lambda cls: None),
+ )
+
+ with pytest.raises(RuntimeError, match='default incoming policy'):
+ adapter.capture('firewall')
+ with pytest.raises(ValueError, match='remote firewall'):
+ adapter.capture('firewall', server_id='remote-1')
+
+
+def test_firewalld_capture_includes_non_default_zones(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ monkeypatch.setattr(adapter.FirewallService, 'get_status', classmethod(
+ lambda cls: {
+ 'active_firewall': 'firewalld',
+ 'firewalld': {
+ 'installed': True, 'running': True, 'default_zone': 'public',
+ },
+ 'ufw': {'installed': False, 'active': False},
+ }))
+
+ def output(argv):
+ if argv[-1] == '--get-zones':
+ return 'public internal'
+ zone = next((part.split('=', 1)[1] for part in argv if part.startswith('--zone=')), '')
+ if argv[-1] == '--list-services':
+ return 'ssh' if zone == 'public' else 'postgresql'
+ if argv[-1] == '--list-ports':
+ return ''
+ if argv[-1] == '--list-rich-rules':
+ return ''
+ raise AssertionError(argv)
+
+ monkeypatch.setattr(adapter, '_run', output)
+
+ payload = adapter.capture('firewall')
+
+ assert {(rule['zone'], rule['service']) for rule in payload['rules']} == {
+ ('public', 'ssh'), ('internal', 'postgresql'),
+ }
+
+
+def test_validate_restore_refuses_ssh_lockout_and_protected_address(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ target = _ufw_payload(rules=[
+ {'kind': 'ufw', 'argv': ['deny', 'from', '127.0.0.0/8']},
+ ])
+ monkeypatch.setattr(
+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),
+ )
+ monkeypatch.setattr(
+ adapter.FirewallService, 'active_ssh_peers', classmethod(lambda cls: set()),
+ )
+
+ refusals = adapter.validate_restore('firewall', target, _ufw_payload())
+
+ assert any('does not admit SSH on port 2222' in item for item in refusals)
+ assert any('protected live address' in item for item in refusals)
+
+
+def test_restore_replays_additions_before_default_and_removals(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ current = _ufw_payload(rules=[
+ {'kind': 'ufw', 'argv': ['allow', '80/tcp']},
+ ])
+ target = _ufw_payload(rules=[
+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},
+ ])
+ monkeypatch.setattr(adapter, 'capture', lambda *_a, **_k: current)
+ monkeypatch.setattr(
+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),
+ )
+ calls = []
+ monkeypatch.setattr(
+ adapter.FirewallService, 'add_rule', classmethod(
+ lambda cls, kind, **values: calls.append(('add', kind, values)) or {'success': True}
+ ),
+ )
+ monkeypatch.setattr(
+ adapter.FirewallService, 'remove_rule', classmethod(
+ lambda cls, kind, **values: calls.append(('remove', kind, values)) or {'success': True}
+ ),
+ )
+
+ result = adapter.restore('firewall', target)
+
+ assert result == {'success': True, 'rules_added': 1, 'rules_removed': 1}
+ assert [call[0] for call in calls] == ['add', 'remove']
+ assert calls[0][2]['port'] == 2222
+ assert calls[1][2]['port'] == 80
+
+
+def test_restore_disables_before_removing_last_rule(monkeypatch):
+ from app.services import restore_point_adapter_firewall as adapter
+
+ current = _ufw_payload(enabled=True, rules=[
+ {'kind': 'ufw', 'argv': ['allow', '2222/tcp']},
+ ])
+ target = _ufw_payload(enabled=False)
+ monkeypatch.setattr(adapter, 'capture', lambda *_a, **_k: current)
+ monkeypatch.setattr(
+ adapter.FirewallService, 'ssh_ports', classmethod(lambda cls: [2222]),
+ )
+ calls = []
+ monkeypatch.setattr(
+ adapter.FirewallService, 'disable', classmethod(
+ lambda cls, firewall=None: calls.append('disable') or {'success': True}
+ ),
+ )
+ monkeypatch.setattr(
+ adapter.FirewallService, 'remove_rule', classmethod(
+ lambda cls, kind, **values: calls.append('remove') or {'success': True}
+ ),
+ )
+
+ assert adapter.restore('firewall', target)['success'] is True
+ assert calls == ['disable', 'remove']
+
+
+def test_firewall_door_checkpoints_only_after_request_validation(app, monkeypatch):
+ from app.services.firewall_service import FirewallService
+ from app.services import restore_point_service
+
+ monkeypatch.setattr(FirewallService, 'get_status', classmethod(lambda cls: {
+ 'active_firewall': 'ufw',
+ 'any_active': False,
+ 'ufw': {'installed': True, 'active': False},
+ 'firewalld': {'installed': False, 'running': False},
+ }))
+ monkeypatch.setattr(
+ FirewallService, '_add_ufw_rule',
+ classmethod(lambda cls, kind, **values: {'success': True}),
+ )
+ captures = []
+ monkeypatch.setattr(
+ restore_point_service, 'auto_capture',
+ lambda *args, **kwargs: captures.append((args, kwargs)),
+ )
+ monkeypatch.setattr(restore_point_service, 'get_adapter', lambda scope: object())
+
+ assert FirewallService.add_rule('port')['success'] is False
+ assert captures == []
+ assert FirewallService.add_rule('port', port=443)['success'] is True
+ assert captures[0][0][:3] == ('firewall', 'firewall', 'add_rule')
diff --git a/backend/tests/test_restore_point_nginx.py b/backend/tests/test_restore_point_nginx.py
new file mode 100644
index 00000000..f5ac1035
--- /dev/null
+++ b/backend/tests/test_restore_point_nginx.py
@@ -0,0 +1,189 @@
+"""Plan 81 M2: nginx vhost restore-point payloads and lifecycle hooks."""
+
+import os
+from types import SimpleNamespace
+
+import pytest
+
+from app.services.nginx_service import NginxService
+from app.services import restore_point_adapter_nginx as adapter
+
+
+def nginx_tree(tmp_path, monkeypatch, fake_subprocess):
+ available = tmp_path / 'sites-available'
+ enabled = tmp_path / 'sites-enabled'
+ available.mkdir()
+ enabled.mkdir()
+ monkeypatch.setattr(NginxService, 'SITES_AVAILABLE', str(available))
+ monkeypatch.setattr(NginxService, 'SITES_ENABLED', str(enabled))
+ monkeypatch.setattr(
+ 'app.services.nginx_service.is_command_available', lambda *a, **k: True,
+ )
+
+ from subprocess_stub import FakeProc
+
+ def tee(argv, kwargs):
+ path = argv[2] if argv[1] == '-a' else argv[1]
+ with open(path, 'a' if argv[1] == '-a' else 'w') as stream:
+ stream.write(kwargs.get('input', ''))
+ return FakeProc()
+
+ def cat(argv, _kwargs):
+ try:
+ with open(argv[1]) as stream:
+ return FakeProc(stdout=stream.read())
+ except OSError:
+ return FakeProc(returncode=1, stderr='unreadable')
+
+ def ln(argv, _kwargs):
+ target, link = argv[-2], argv[-1]
+ with open(link, 'w') as stream:
+ stream.write(target)
+ return FakeProc()
+
+ def rm(argv, _kwargs):
+ for path in argv[1:]:
+ if not path.startswith('-') and os.path.exists(path):
+ os.remove(path)
+ return FakeProc()
+
+ fake_subprocess.when(['tee'], tee)
+ fake_subprocess.when(['cat'], cat)
+ fake_subprocess.when(['ln'], ln)
+ fake_subprocess.when(['rm'], rm)
+ fake_subprocess.script(['nginx', '-t'])
+ fake_subprocess.script(['systemctl'])
+ return available, enabled
+
+
+def test_capture_includes_exists_enabled_and_content(nginx_tree):
+ available, enabled = nginx_tree
+ (available / 'shop').write_text('server { listen 80; }')
+ (enabled / 'shop').write_text(str(available / 'shop'))
+
+ assert adapter.capture('shop') == {
+ 'exists': True,
+ 'enabled': True,
+ 'content': 'server { listen 80; }',
+ }
+
+
+def test_capture_refuses_unreadable_existing_vhost(nginx_tree, monkeypatch):
+ available, _ = nginx_tree
+ (available / 'shop').write_text('present')
+ monkeypatch.setattr(
+ NginxService, 'read_vhost', classmethod(lambda cls, name: None),
+ )
+
+ with pytest.raises(RuntimeError, match='could not be read'):
+ adapter.capture('shop')
+
+
+ '../outside', '..\\outside', '/etc/nginx/nginx.conf', 'C:\\Windows\\win.ini',
+])
+def test_scope_rejects_paths_outside_the_vhost_directory(nginx_tree, name):
+ with pytest.raises(ValueError, match='safe filename'):
+ adapter.capture(name)
+
+
+def test_restore_round_trip_reproduces_content_and_disabled_state(nginx_tree):
+ available, enabled = nginx_tree
+ saved = {
+ 'exists': True,
+ 'enabled': False,
+ 'content': 'server { listen 80; server_name saved.test; }',
+ }
+ assert adapter.restore('shop', saved)['success'] is True
+ assert adapter.capture('shop') == saved
+
+ changed = {
+ 'exists': True,
+ 'enabled': True,
+ 'content': 'server { listen 80; server_name changed.test; }',
+ }
+ assert adapter.restore('shop', changed)['success'] is True
+ assert (enabled / 'shop').exists()
+
+ assert adapter.restore('shop', saved)['success'] is True
+ assert (available / 'shop').read_text() == saved['content']
+ assert not (enabled / 'shop').exists()
+
+
+def test_restore_absent_uses_delete_lifecycle_door(monkeypatch):
+ calls = []
+ monkeypatch.setattr(
+ NginxService, 'delete_site',
+ classmethod(lambda cls, name: calls.append(('delete', name)) or {
+ 'success': True,
+ }),
+ )
+
+ result = adapter.restore('shop', {
+ 'exists': False, 'enabled': False, 'content': None,
+ })
+
+ assert result['success'] is True
+ assert calls == [('delete', 'shop')]
+
+
+def test_lifecycle_hooks_capture_once_per_public_action(
+ app, nginx_tree, monkeypatch):
+ from app.services import restore_point_service
+
+ available, _ = nginx_tree
+ existing = restore_point_service.get_adapter('nginx_vhost')
+ restore_point_service.register_adapter('nginx_vhost', adapter)
+ captured = []
+ monkeypatch.setattr(
+ restore_point_service, 'capture',
+ lambda *args, **kwargs: captured.append((args, kwargs)),
+ )
+
+ try:
+ assert NginxService.write_vhost('shop', 'server {}')['success']
+ assert NginxService.disable_site('shop')['success']
+ assert NginxService.enable_site('shop')['success']
+ assert NginxService.delete_site('shop')['success']
+ finally:
+ if existing is None:
+ restore_point_service.ADAPTERS.pop('nginx_vhost', None)
+ else:
+ restore_point_service.register_adapter('nginx_vhost', existing)
+
+ assert not (available / 'shop').exists()
+ assert [item[1]['label'] for item in captured] == [
+ 'before nginx_vhost.write_vhost',
+ 'before nginx_vhost.disable_site',
+ 'before nginx_vhost.enable_site',
+ 'before nginx_vhost.delete_site',
+ ]
+
+
+def test_site_domain_writer_does_not_enable_twice(monkeypatch):
+ from app.services.site_domain_service import SiteDomainService
+
+ app = SimpleNamespace(name='shop')
+ monkeypatch.setattr(
+ SiteDomainService, 'app_vhost_kwargs',
+ classmethod(lambda cls, target, force_type=None: ({
+ 'name': target.name,
+ 'app_type': 'docker',
+ 'domains': ['shop.test'],
+ 'port': 8080,
+ }, None)),
+ )
+ monkeypatch.setattr(
+ NginxService, 'create_site',
+ classmethod(lambda cls, **kwargs: {'success': True}),
+ )
+ monkeypatch.setattr(
+ NginxService, 'enable_site',
+ classmethod(lambda cls, name: pytest.fail('redundant enable_site call')),
+ )
+
+ assert SiteDomainService.write_app_vhost(app) == {
+ 'nginx': {'success': True},
+ 'warning': None,
+ }
diff --git a/backend/tests/test_serializable_mixin.py b/backend/tests/test_serializable_mixin.py
index 09118073..658e2262 100644
--- a/backend/tests/test_serializable_mixin.py
+++ b/backend/tests/test_serializable_mixin.py
@@ -23,10 +23,10 @@ EXPECTED = {
'CloudflareTunnel': {'account_id', 'created_at', 'dns_provider_config_id', 'id', 'name', 'tunnel_id'},
'CronRun': {'created_at', 'duration_seconds', 'exit_code', 'finished_at', 'id', 'job_id', 'output_tail', 'started_at', 'status'},
'DNSRecord': {'content', 'created_at', 'id', 'name', 'priority', 'provider_record_id', 'proxied', 'record_type', 'ttl', 'zone_id'},
- 'DnsChange': {'action', 'content', 'created_at', 'dns_provider_config_id', 'error', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'result', 'source'},
+ 'DnsChange': {'action', 'before_json', 'content', 'created_at', 'dns_provider_config_id', 'error', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'result', 'source'},
'HealthCheck': {'checked_at', 'component_id', 'error', 'id', 'response_time', 'status', 'status_code'},
'ImageUpdateCheck': {'application_id', 'checked_at', 'current_digest', 'error_message', 'id', 'image_ref', 'latest_digest', 'status', 'update_available'},
- 'ManagedDnsRecord': {'app_id', 'content', 'created_at', 'id', 'name', 'provider', 'provider_record_id', 'provider_zone_id', 'record_type', 'source', 'updated_at'},
+ 'ManagedDnsRecord': {'app_id', 'content', 'created_at', 'id', 'name', 'priority', 'provider', 'provider_record_id', 'provider_zone_id', 'proxied', 'record_type', 'source', 'ttl', 'updated_at'},
'ResourceTag': {'created_at', 'id', 'resource_id', 'resource_type', 'tag'},
'ServerCommand': {'command_data', 'command_type', 'completed_at', 'created_at', 'error', 'exit_code', 'id', 'max_retries', 'queued', 'result', 'retry_count', 'server_id', 'started_at', 'status', 'user_id'},
'ServerMetrics': {'container_count', 'container_running', 'cpu_percent', 'disk_percent', 'disk_used', 'extra', 'id', 'memory_percent', 'memory_used', 'network_rx', 'network_rx_rate', 'network_tx', 'network_tx_rate', 'server_id', 'timestamp'},