ServerKit is a lightweight, modern server control panel for managing web applications, databases, and services on your VPS or dedicated server. Built with Python/Flask backend and React frontend.
Python astracloudflarecontrol-panelcyberpaneldnsfablehosting-control-panelhosting-panelkimi-k3server-managementserverkitubuntu-web-panelwebserver
feat(sites): base-domain registry so sites can publish under multiple domains
Juan Denisf76da49ab446
diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.pyindex 881e86a2..6e69383b 100644--- a/backend/app/models/__init__.py+++ b/backend/app/models/__init__.py@@ -10,6 +10,7 @@ from app.models.environment import Environmentfrom app.models.shared_resource import ResourceTag, SharedVariableGroup, SharedVariable, SharedVariableGroupAttachmentfrom app.models.application_preview import ApplicationPreview, ApplicationPreviewSettingsfrom app.models.proxy_stack import ProxyStack+from app.models.site_base_domain import SiteBaseDomainfrom app.models.deployment_job import DeploymentJob, DeploymentJobLogfrom app.models.system_settings import SystemSettingsfrom app.models.audit_log import AuditLog@@ -99,4 +100,5 @@ __all__ = ['ResourceTag', 'SharedVariableGroup', 'SharedVariable', 'SharedVariableGroupAttachment','ApplicationPreview', 'ApplicationPreviewSettings','ProxyStack',+ 'SiteBaseDomain',]diff --git a/backend/app/models/site_base_domain.py b/backend/app/models/site_base_domain.pynew file mode 100644index 00000000..1ecee47c--- /dev/null+++ b/backend/app/models/site_base_domain.py@@ -0,0 +1,52 @@+"""Base domains that managed sites can be published under.++ServerKit publishes a managed site at ``<slug>.<base_domain>``. Historically+there was exactly one base domain (the ``sites_base_domain`` setting); this+model lets an operator register several — e.g. ``example.com`` and ``toto.com`` —+each with its own DNS provider connection and wildcard certificate, so a new+site can choose which one to live under (``a.example.com`` vs ``a.toto.com``).++Exactly one row is the default, used when a create request doesn't name a base.+On upgrade the legacy single setting is lazily materialised into the default row+(see SiteBaseDomainService.ensure_seeded); a fresh/dev install with no rows keeps+falling back to the ``sites_base_domain`` setting / ``SITES_BASE_DOMAIN`` config.+"""+from datetime import datetime++from app import db+++class SiteBaseDomain(db.Model):+ __tablename__ = 'site_base_domains'++ DNS_MODES = ('wildcard', 'per-site')++ id = db.Column(db.Integer, primary_key=True)+ domain = db.Column(db.String(253), nullable=False, unique=True)+ is_default = db.Column(db.Boolean, nullable=False, default=False)+ # wildcard: one *.<domain> record covers every site; per-site: each site gets+ # its own A record auto-created via the provider.+ dns_mode = db.Column(db.String(20), nullable=False, default='wildcard')+ # True once a *.<domain> wildcard certificate exists, so its sites serve TLS.+ https_enabled = db.Column(db.Boolean, nullable=False, default=False)+ # The connected DNS provider that owns this domain's zone — used to create the+ # wildcard record and issue the wildcard cert. Nullable: a domain may be+ # registered before HTTPS is set up, or have its DNS managed manually.+ dns_provider_config_id = db.Column(+ db.Integer,+ db.ForeignKey('dns_provider_configs.id', ondelete='SET NULL'),+ nullable=True,+ )+ created_at = db.Column(db.DateTime, default=datetime.utcnow)+ updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)++ def to_dict(self):+ return {+ 'id': self.id,+ 'domain': self.domain,+ 'is_default': self.is_default,+ 'dns_mode': self.dns_mode if self.dns_mode in self.DNS_MODES else 'wildcard',+ 'https_enabled': bool(self.https_enabled),+ 'dns_provider_config_id': self.dns_provider_config_id,+ 'created_at': self.created_at.isoformat() if self.created_at else None,+ }diff --git a/backend/app/services/site_base_domain_service.py b/backend/app/services/site_base_domain_service.pynew file mode 100644index 00000000..55712eb1--- /dev/null+++ b/backend/app/services/site_base_domain_service.py@@ -0,0 +1,149 @@+"""CRUD + resolution for the managed-site base-domain registry.++The registry (``site_base_domains``) lets managed sites be published under any of+several base domains (``example.com``, ``toto.com``, …), each with its own DNS+provider + wildcard cert. Exactly one row is the default. This service owns the+writes; SiteDomainService reads through it for routing/cert decisions.++Back-compat: installs that only ever had the single ``sites_base_domain`` setting+have zero rows. ``ensure_seeded`` materialises that legacy value into the default+row the moment a second domain is registered, so the two never disagree.+"""+import re++from app import db+from app.models.site_base_domain import SiteBaseDomain+from app.models.system_settings import SystemSettings++_DOMAIN_RE = re.compile(+ r'^(?:[a-z0-9](?:[a-z0-9\-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$'+)+++def normalize_domain(value):+ """Lowercase, trim, drop a leading dot. Returns '' for falsy input."""+ return (str(value).strip().lstrip('.').lower()) if value else ''+++class SiteBaseDomainService:++ @staticmethod+ def is_valid_domain(domain):+ d = normalize_domain(domain)+ return bool(d) and len(d) <= 253 and bool(_DOMAIN_RE.match(d))++ # ------------------------------------------------------------------+ # Seeding / back-compat+ # ------------------------------------------------------------------+ @classmethod+ def ensure_seeded(cls):+ """If the registry is empty but a legacy ``sites_base_domain`` setting+ exists, create the default row from the legacy sites settings so the+ registry and the old single-domain settings agree. No-op otherwise (and+ deliberately does NOT seed the dev-only ``SITES_BASE_DOMAIN`` config —+ only a persisted operator setting)."""+ if SiteBaseDomain.query.first() is not None:+ return None+ legacy = normalize_domain(SystemSettings.get('sites_base_domain'))+ if not legacy:+ return None+ mode = (SystemSettings.get('sites_dns_mode') or 'wildcard')+ row = SiteBaseDomain(+ domain=legacy,+ is_default=True,+ dns_mode=mode if mode in SiteBaseDomain.DNS_MODES else 'wildcard',+ https_enabled=bool(SystemSettings.get('sites_https_enabled', False)),+ )+ db.session.add(row)+ db.session.commit()+ return row++ # ------------------------------------------------------------------+ # Reads+ # ------------------------------------------------------------------+ @classmethod+ def list_rows(cls):+ return SiteBaseDomain.query.order_by(+ SiteBaseDomain.is_default.desc(), SiteBaseDomain.domain.asc()).all()++ @classmethod+ def get(cls, domain):+ return SiteBaseDomain.query.filter_by(domain=normalize_domain(domain)).first()++ @classmethod+ def default(cls):+ """The default row (explicit flag, else the oldest), or None."""+ return (SiteBaseDomain.query.filter_by(is_default=True).first()+ or SiteBaseDomain.query.order_by(SiteBaseDomain.id.asc()).first())++ # ------------------------------------------------------------------+ # Writes+ # ------------------------------------------------------------------+ @classmethod+ def add(cls, domain, dns_provider_config_id=None, dns_mode='wildcard', make_default=False):+ """Register a base domain. Seeds the legacy default first, so the first+ added domain doesn't silently become the sole/default and orphan the old+ single-domain config. Returns ``{'success', 'base'|'error'}``."""+ d = normalize_domain(domain)+ if not cls.is_valid_domain(d):+ return {'success': False, 'error': f'Invalid domain: {domain}'}+ cls.ensure_seeded()+ if cls.get(d):+ return {'success': False, 'error': f'{d} is already registered.'}+ mode = dns_mode if dns_mode in SiteBaseDomain.DNS_MODES else 'wildcard'+ first = SiteBaseDomain.query.first() is None+ row = SiteBaseDomain(+ domain=d, dns_mode=mode, dns_provider_config_id=dns_provider_config_id,+ is_default=bool(make_default or first),+ )+ db.session.add(row)+ db.session.flush()+ if row.is_default:+ cls._demote_others(row.id)+ db.session.commit()+ return {'success': True, 'base': row.to_dict()}++ @classmethod+ def set_default(cls, domain):+ row = cls.get(domain)+ if not row:+ return {'success': False, 'error': f'{domain} is not registered.'}+ row.is_default = True+ cls._demote_others(row.id)+ db.session.commit()+ return {'success': True, 'base': row.to_dict()}++ @classmethod+ def update(cls, domain, dns_mode=None, dns_provider_config_id=None, https_enabled=None):+ row = cls.get(domain)+ if not row:+ return {'success': False, 'error': f'{domain} is not registered.'}+ if dns_mode is not None and dns_mode in SiteBaseDomain.DNS_MODES:+ row.dns_mode = dns_mode+ if dns_provider_config_id is not None:+ row.dns_provider_config_id = dns_provider_config_id or None+ if https_enabled is not None:+ row.https_enabled = bool(https_enabled)+ db.session.commit()+ return {'success': True, 'base': row.to_dict()}++ @classmethod+ def remove(cls, domain):+ row = cls.get(domain)+ if not row:+ return {'success': False, 'error': f'{domain} is not registered.'}+ was_default = row.is_default+ db.session.delete(row)+ db.session.flush()+ if was_default:+ # Promote the oldest survivor so there's always a default.+ successor = SiteBaseDomain.query.order_by(SiteBaseDomain.id.asc()).first()+ if successor:+ successor.is_default = True+ db.session.commit()+ return {'success': True}++ @staticmethod+ def _demote_others(keep_id):+ SiteBaseDomain.query.filter(SiteBaseDomain.id != keep_id).update(+ {'is_default': False}, synchronize_session=False)diff --git a/backend/app/services/site_domain_service.py b/backend/app/services/site_domain_service.pyindex f1ed6b5f..7ad5fa5e 100644--- a/backend/app/services/site_domain_service.py+++ b/backend/app/services/site_domain_service.py@@ -22,17 +22,73 @@ from app.utils.slug import slugify as _slugifyclass SiteDomainService:DEFAULT_BASE_DOMAIN = 'lvh.me'+ @staticmethod+ def _norm(value):+ return (str(value).strip().lstrip('.').lower()) if value else ''++ @classmethod+ def _default_row(cls):+ """The default SiteBaseDomain row, or None when the registry is empty+ (legacy single-setting / dev installs)."""+ try:+ from app.services.site_base_domain_service import SiteBaseDomainService+ return SiteBaseDomainService.default()+ except Exception:+ return None++ @classmethod+ def _row_for(cls, base):+ """The registry row for ``base`` (or the default row when base is None),+ or None when there's no matching/registered row."""+ try:+ from app.services.site_base_domain_service import SiteBaseDomainService+ if not base:+ return SiteBaseDomainService.default()+ return SiteBaseDomainService.get(base)+ except Exception:+ return None+@classmethoddef base_domain(cls):- """The configured base domain, or '' when site routing is not set up.+ """The *default* base domain, or '' when site routing is not set up.- Prefers the runtime setting (editable in-app) over the config default so- an operator can change it without redeploying.+ Prefers the registry's default row; falls back to the legacy+ ``sites_base_domain`` setting, then the ``SITES_BASE_DOMAIN`` config+ default (so dev / not-yet-migrated installs keep working unchanged)."""+ row = cls._default_row()+ if row:+ return row.domainval = SystemSettings.get('sites_base_domain')if val:- return str(val).strip().lstrip('.').lower()- return (current_app.config.get('SITES_BASE_DOMAIN') or '').strip().lstrip('.').lower()+ return cls._norm(val)+ return cls._norm(current_app.config.get('SITES_BASE_DOMAIN'))++ @classmethod+ def all_base_domains(cls):+ """Every base domain a site may be published under (registry rows, else+ the single legacy base). Empty when site routing isn't configured."""+ try:+ from app.services.site_base_domain_service import SiteBaseDomainService+ rows = SiteBaseDomainService.list_rows()+ if rows:+ return [r.domain for r in rows]+ except Exception:+ pass+ base = cls.base_domain()+ return [base] if base else []++ @classmethod+ def resolve_base(cls, base=None):+ """The concrete base domain to publish under. An explicit ``base`` is+ honoured only when it's a registered/legacy base — an unknown value falls+ back to the default rather than publishing under an unmanaged domain."""+ if not base:+ return cls.base_domain()+ b = cls._norm(base)+ if b in cls.all_base_domains():+ return b+ return cls.base_domain()@classmethoddef server_ip(cls):@@ -64,29 +120,47 @@ class SiteDomainService:return None@classmethod- def https_enabled(cls):- """True once the wildcard certificate for the base domain is set up, so- managed subdomains should be served over HTTPS (Phase 5)."""- return bool(SystemSettings.get('sites_https_enabled', False))+ def https_enabled(cls, base=None):+ """True once the wildcard certificate for the given base (default when+ None) is set up, so its managed subdomains should be served over HTTPS.++ Reads the registry row when present; falls back to the legacy+ ``sites_https_enabled`` setting for the default/legacy base."""+ row = cls._row_for(base)+ if row is not None:+ return bool(row.https_enabled)+ if base is None or cls._norm(base) == cls.base_domain():+ return bool(SystemSettings.get('sites_https_enabled', False))+ return False@classmethod- def wildcard_cert_paths(cls):- """(fullchain, privkey) paths for the base domain's wildcard cert, or- (None, None) when no base domain is configured."""- base = cls.base_domain()+ def wildcard_cert_paths(cls, base=None):+ """(fullchain, privkey) paths for a base's wildcard cert (default base+ when None), or (None, None) when no base domain is configured."""+ base = cls.resolve_base(base)if not base:return (None, None)return (f'/etc/letsencrypt/live/{base}/fullchain.pem',f'/etc/letsencrypt/live/{base}/privkey.pem')+ @classmethod+ def covering_base(cls, host):+ """The registered base domain whose wildcard covers ``host`` (host is the+ base or a subdomain of it), longest match wins, or None. Used to pick the+ right per-base certificate for a site's domains."""+ if not host:+ return None+ best = None+ for base in cls.all_base_domains():+ if host == base or host.endswith('.' + base):+ if best is None or len(base) > len(best):+ best = base+ return best+@classmethoddef covers(cls, host):- """Whether the base domain's wildcard cert covers ``host`` — i.e. host is- the base domain or a direct subdomain of it."""- base = cls.base_domain()- if not base or not host:- return False- return host == base or host.endswith('.' + base)+ """Whether *any* registered base domain's wildcard cert covers ``host``."""+ return cls.covering_base(host) is not None@staticmethoddef slugify(name):@@ -94,10 +168,10 @@ class SiteDomainService:return _slugify(name) or 'site'@classmethod- def subdomain_for(cls, name):- """``<slug>.<base_domain>`` for a site name, or ``None`` when no base- domain is configured (site routing disabled)."""- base = cls.base_domain()+ def subdomain_for(cls, name, base=None):+ """``<slug>.<base>`` for a site name (default base when None), or ``None``+ when no base domain is configured (site routing disabled)."""+ base = cls.resolve_base(base)if not base:return Nonereturn f'{cls.slugify(name)}.{base}'@@ -110,24 +184,31 @@ class SiteDomainService:return f'{scheme}://{host}'@classmethod- def dns_mode(cls):- """How managed-site subdomains get their DNS:+ def dns_mode(cls, base=None):+ """How a base's managed-site subdomains get their DNS (default base when+ None):- * ``wildcard`` (default) — one ``*.<base_domain>`` record covers every site,- so a new site needs no per-site DNS work, and+ * ``wildcard`` (default) — one ``*.<base>`` record covers every site, and* ``per-site`` — each site gets its own A record, auto-created via a- connected provider, so every site is an explicit, visible record.- """+ connected provider.++ Reads the registry row when present; falls back to the legacy+ ``sites_dns_mode`` setting for the default/legacy base."""+ row = cls._row_for(base)+ if row is not None:+ return row.dns_mode if row.dns_mode in ('wildcard', 'per-site') else 'wildcard'val = (SystemSettings.get('sites_dns_mode') or '').strip().lower()return val if val in ('wildcard', 'per-site') else 'wildcard'@classmethoddef ensure_site_dns(cls, host):- """Auto-create a managed site's A record when in ``per-site`` mode (via a- connected provider, ownership-guarded + logged). In ``wildcard`` mode this is- a no-op — the single ``*.<base>`` record already covers ``host``. Never raises;- returns the provider result (or a ``skipped``/``no_server_ip`` descriptor)."""- if not host or cls.dns_mode() != 'per-site':+ """Auto-create a managed site's A record when its base is in ``per-site``+ mode (via a connected provider, ownership-guarded + logged). In ``wildcard``+ mode this is a no-op — the single ``*.<base>`` record already covers ``host``.+ Never raises; returns the provider result (or a ``skipped``/``no_server_ip``+ descriptor)."""+ base = cls.covering_base(host)+ if not host or cls.dns_mode(base) != 'per-site':return {'created': False, 'skipped': True, 'reason': 'wildcard'}ip = cls.server_ip()if not ip:@@ -348,9 +429,9 @@ class SiteDomainService:Handles all host-nginx app types: docker/wordpress andpython/flask/django reverse-proxy to the app's port; php/static serve a- filesystem root. Serves the base-domain wildcard cert when HTTPS is- enabled and every domain is a covered subdomain (custom domains bring- their own cert). Best-effort — never raises; returns ``{'nginx',+ filesystem root. Serves a base's wildcard cert when every domain is a+ subdomain of that *same* base and its HTTPS is enabled (custom domains+ bring their own cert). Best-effort — never raises; returns ``{'nginx','warning'}`` (``nginx`` is ``None`` when nothing was written)."""from app.models.domain import Domain@@ -360,9 +441,12 @@ class SiteDomainService:if not domains:return {'nginx': None, 'warning': None}+ # Pick a wildcard cert only when all domains sit under one base (whichever+ # base covers them) and that base has HTTPS set up.ssl_cert = ssl_key = None- if cls.https_enabled() and all(cls.covers(d) for d in domains):- ssl_cert, ssl_key = cls.wildcard_cert_paths()+ cover = cls.covering_base(domains[0])+ if cover and cls.https_enabled(cover) and all(cls.covering_base(d) == cover for d in domains):+ ssl_cert, ssl_key = cls.wildcard_cert_paths(cover)kwargs, reason = cls._vhost_create_kwargs(app, domains, ssl_cert, ssl_key, force_type)if reason:@@ -380,11 +464,12 @@ class SiteDomainService:return {'nginx': res, 'warning': None}@classmethod- def give_subdomain(cls, app, label=None):+ def give_subdomain(cls, app, label=None, base=None):"""One-click 'give this app a subdomain': publish ``app`` at- ``<label>.<base_domain>`` (label defaults to the app-name slug). Creates the- primary Domain row, (re)writes its nginx vhost, and — in per-site DNS mode —- auto-creates the A record (wildcard mode relies on ``*.<base>``).+ ``<label>.<base>`` (label defaults to the app-name slug; ``base`` defaults+ to the default registered base domain). Creates the primary Domain row,+ (re)writes its nginx vhost, and — in per-site DNS mode — auto-creates the A+ record (wildcard mode relies on ``*.<base>``).Returns ``{success, host, url, dns, nginx, warning}`` or``{success: False, error}``.@@ -392,7 +477,7 @@ class SiteDomainService:from app import dbfrom app.models.domain import Domain- base = cls.base_domain()+ base = cls.resolve_base(base)if not base:return {'success': False, 'error': 'Set the managed-sites base domain first (Settings).'}@@ -431,5 +516,5 @@ class SiteDomainService:cls.notify_publishing_gaps()return {'success': True, 'host': host,- 'url': cls.site_url(host, ssl=cls.https_enabled() and cls.covers(host)),+ 'url': cls.site_url(host, ssl=cls.https_enabled(base) and cls.covers(host)),'dns': dns, 'nginx': nginx, 'warning': warning}diff --git a/backend/migrations/versions/040_site_base_domains.py b/backend/migrations/versions/040_site_base_domains.pynew file mode 100644index 00000000..954d64e3--- /dev/null+++ b/backend/migrations/versions/040_site_base_domains.py@@ -0,0 +1,55 @@+"""Registry of base domains managed sites can be published under.++Adds:+- site_base_domains (one row per base domain, e.g. example.com / toto.com; each+ with its own DNS provider + wildcard-cert state; exactly one is the default)++Rows are seeded lazily by SiteBaseDomainService.ensure_seeded from the legacy+``sites_base_domain`` setting the first time a second domain is registered, so+this migration only creates the (empty) table.++Idempotent: MigrationService runs _fix_missing_columns() + db.create_all() on boot+before Alembic, so guard on the live schema.++Revision ID: 040_site_base_domains+Revises: 039_deployment_job_links+Create Date: 2026-07-01+"""+from alembic import op+import sqlalchemy as sa++revision = '040_site_base_domains'+down_revision = '039_deployment_job_links'+branch_labels = None+depends_on = None+++def upgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ existing = set(inspector.get_table_names())++ if 'site_base_domains' not in existing:+ op.create_table(+ 'site_base_domains',+ sa.Column('id', sa.Integer, nullable=False),+ sa.Column('domain', sa.String(253), nullable=False),+ sa.Column('is_default', sa.Boolean, nullable=False, server_default=sa.false()),+ sa.Column('dns_mode', sa.String(20), nullable=False, server_default='wildcard'),+ sa.Column('https_enabled', sa.Boolean, nullable=False, server_default=sa.false()),+ sa.Column('dns_provider_config_id', sa.Integer, nullable=True),+ sa.Column('created_at', sa.DateTime, nullable=True),+ sa.Column('updated_at', sa.DateTime, nullable=True),+ sa.PrimaryKeyConstraint('id'),+ sa.ForeignKeyConstraint(['dns_provider_config_id'], ['dns_provider_configs.id'],+ ondelete='SET NULL'),+ sa.UniqueConstraint('domain', name='uq_site_base_domain'),+ )+++def downgrade():+ conn = op.get_bind()+ inspector = sa.inspect(conn)+ existing = set(inspector.get_table_names())+ if 'site_base_domains' in existing:+ op.drop_table('site_base_domains')diff --git a/backend/tests/test_site_base_domains.py b/backend/tests/test_site_base_domains.pynew file mode 100644index 00000000..f1f9639d--- /dev/null+++ b/backend/tests/test_site_base_domains.py@@ -0,0 +1,127 @@+"""Proving tests for the base-domain registry (multiple base domains).++A managed site can be published under any registered base domain — a.example.com+or a.toto.com — each with its own DNS mode / HTTPS state, defaulting to the one+marked default. Back-compat: the legacy single ``sites_base_domain`` setting is+materialised into the default row the first time a second domain is registered.+"""+++def _set(key, value):+ from app import db+ from app.services.settings_service import SettingsService+ SettingsService.set(key, value)+ db.session.commit()+++def _mk_app(name='Acme', port=8500, app_type='docker'):+ from app import db+ from app.models import User, Application+ from werkzeug.security import generate_password_hash+ u = User(email=f'{name}@bd.local', username=f'bd-{name}'.replace(' ', '-').lower(),+ password_hash=generate_password_hash('x'), role=User.ROLE_ADMIN, is_active=True)+ db.session.add(u)+ db.session.commit()+ a = Application(name=name, app_type=app_type, user_id=u.id, root_path=f'/srv/{name}', port=port)+ db.session.add(a)+ db.session.commit()+ return a+++# ── seeding + registry CRUD ──────────────────────────────────────────────────++def test_add_seeds_legacy_default_then_registers_new(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ _set('sites_base_domain', 'example.com')+ _set('sites_https_enabled', True)++ res = SiteBaseDomainService.add('toto.com')+ assert res['success']+ domains = [r.domain for r in SiteBaseDomainService.list_rows()]+ assert domains == ['example.com', 'toto.com'] # default sorts first+ # The legacy domain became the default row, carrying its HTTPS state.+ assert SiteDomainService.base_domain() == 'example.com'+ assert SiteBaseDomainService.default().domain == 'example.com'+ assert SiteBaseDomainService.get('example.com').https_enabled is True+ assert SiteBaseDomainService.get('toto.com').is_default is False+++def test_add_make_default_demotes_others(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ _set('sites_base_domain', 'example.com')+ SiteBaseDomainService.add('toto.com', make_default=True)+ assert SiteBaseDomainService.default().domain == 'toto.com'+ assert SiteBaseDomainService.get('example.com').is_default is False+++def test_remove_default_promotes_successor(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ _set('sites_base_domain', 'example.com')+ SiteBaseDomainService.add('toto.com')+ SiteBaseDomainService.remove('example.com')+ assert SiteDomainService.base_domain() == 'toto.com'+ assert SiteBaseDomainService.default().domain == 'toto.com'+++def test_invalid_domain_rejected(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ assert SiteBaseDomainService.add('not a domain').get('success') is False+ assert SiteBaseDomainService.add('nodots').get('success') is False+++# ── base-aware resolution in SiteDomainService ───────────────────────────────++def test_subdomain_for_picks_the_named_base(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ _set('sites_base_domain', 'example.com')+ SiteBaseDomainService.add('toto.com')+ assert SiteDomainService.subdomain_for('My Blog') == 'my-blog.example.com'+ assert SiteDomainService.subdomain_for('My Blog', base='toto.com') == 'my-blog.toto.com'+ # An unregistered base falls back to the default, never publishes under it.+ assert SiteDomainService.subdomain_for('X', base='unmanaged.net') == 'x.example.com'+++def test_covering_base_longest_match(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ _set('sites_base_domain', 'example.com')+ SiteBaseDomainService.add('apps.example.com') # more specific base+ SiteBaseDomainService.add('toto.com')+ assert SiteDomainService.covering_base('a.toto.com') == 'toto.com'+ assert SiteDomainService.covering_base('a.apps.example.com') == 'apps.example.com'+ assert SiteDomainService.covering_base('a.example.com') == 'example.com'+ assert SiteDomainService.covers('a.nope.net') is False+++def test_https_and_dns_mode_are_per_base(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ _set('sites_base_domain', 'example.com')+ _set('sites_https_enabled', True) # seeds example.com https=on+ SiteBaseDomainService.add('toto.com', dns_mode='per-site')+ assert SiteDomainService.https_enabled('example.com') is True+ assert SiteDomainService.https_enabled('toto.com') is False+ assert SiteDomainService.dns_mode('example.com') == 'wildcard'+ assert SiteDomainService.dns_mode('toto.com') == 'per-site'+ fc, key = SiteDomainService.wildcard_cert_paths('toto.com')+ assert fc.endswith('/toto.com/fullchain.pem')+++def test_give_subdomain_under_chosen_base(app, monkeypatch):+ from app.services.site_base_domain_service import SiteBaseDomainService+ from app.services.site_domain_service import SiteDomainService+ from app.services.nginx_service import NginxService+ from app.models.domain import Domain+ _set('sites_base_domain', 'example.com')+ SiteBaseDomainService.add('toto.com')+ a = _mk_app(name='Shop', port=8600)++ monkeypatch.setattr(NginxService, 'create_site', staticmethod(lambda **k: {'success': True}))+ monkeypatch.setattr(NginxService, 'enable_site', staticmethod(lambda name: {'success': True}))++ res = SiteDomainService.give_subdomain(a, base='toto.com')+ assert res['success'] and res['host'] == 'shop.toto.com'+ assert Domain.query.filter_by(name='shop.toto.com', application_id=a.id).first() is not None