Struct DomainManager 

pub struct DomainManager { /* private fields */ }

Domain management service.

Implementations

impl DomainManager

pub fn new( pool: PgPool, verification_service: Arc<DomainVerificationService>, ) -> Self

Create a new domain manager with the default DomainPolicy.

pub fn with_policy( pool: PgPool, verification_service: Arc<DomainVerificationService>, policy: DomainPolicy, ) -> Self

Create a domain manager with an explicit policy.

pub async fn create_domain( &self, tenant_id: Uuid, req: CreateDomainRequest, ) -> ProxyResult<DomainResponse>

Create a new domain for a tenant.

The name is normalised first and stored in that form, so that the uniqueness check, the Host-header match and the certificate all see one spelling. A reserved name is refused outright.

pub async fn get_domain( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<Option<DomainResponse>>

Get a domain by ID for a tenant.

pub async fn list_domains(&self, tenant_id: Uuid) -> ProxyResult<Vec<Domain>>

List all domains for a tenant.

pub async fn delete_domain( &self, id: Uuid, tenant_id: Uuid, cert_store: &CertificateStore, ) -> ProxyResult<bool>

Delete a domain, and every certificate linked to it.

The certificate rows go with the domain row; cert_store is told as well, so its files and its memory cache do not go on holding a private key for a domain that no longer exists. A certificate is only removed if it is linked to this domain: a row for the same name with no domain is the operator’s, and is left alone.

pub async fn verify_domain( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<VerificationResult>

Verify a domain.

Throttled per domain: one attempt per verification_min_interval, and at most verification_max_attempts in all. Refused once the challenge or the registration has expired. An already-verified domain answers verified without checking again.

pub async fn find_live_http_challenge( &self, token: &str, ) -> ProxyResult<Option<HttpChallenge>>

Look up a live HTTP verification challenge by its token.

Exposed so the well-known endpoint can answer challenges without reaching past this service for the pool. The caller must still check that the request arrived for the returned domain.

pub async fn update_domain( &self, id: Uuid, tenant_id: Uuid, req: UpdateDomainRequest, ) -> ProxyResult<Domain>

Apply a partial update to a domain.

The domain name cannot be changed – see UpdateDomainRequest for why – so this only moves the verification method and the SSL provider.

pub async fn upload_certificate( &self, id: Uuid, tenant_id: Uuid, cert_store: &CertificateStore, req: UploadCertificateRequest, ) -> ProxyResult<Domain>

Store a certificate an operator supplied, after checking it.

The checks are the point. An unchecked upload gives a listener that accepts the certificate now and fails every handshake later: the key may not match the chain, the certificate may be expired, or it may be for another domain entirely. All three are refused here, with a message saying which.

And the domain must be verified. What is stored here is served by the TLS listener for that name, to everyone; before this check, a tenant could register any name – the platform’s own included – and have its certificate served for it without proving anything. The chain must also be trusted according to DomainPolicy::upload_trust.

pub async fn queue_ssl_issuance( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<Domain>

Queue a verified ACME domain for certificate issuance.

Sets state and returns; the work is done by the issuance worker. That is the whole endpoint, and deliberately so: an ACME order is several round trips to the CA plus a challenge the CA has to fetch back from us, and retrying under a rate limit is the normal failure mode. Doing it inline would hold the request open and let a client timeout orphan an order the CA had already started.

Idempotent, and also the way to retry after a failure – it clears the attempt count and the backoff.

pub async fn enable_domain( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<bool>

Enable a verified domain.

pub async fn disable_domain( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<bool>

Disable a domain.

pub async fn create_route( &self, domain_id: Uuid, tenant_id: Uuid, req: CreateDomainRouteRequest, ) -> ProxyResult<DomainRoute>

Create a route for a verified domain, within the per-domain quota.

pub async fn get_route( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<Option<DomainRoute>>

Get a route by ID.

pub async fn list_routes_for_domain( &self, domain_id: Uuid, tenant_id: Uuid, ) -> ProxyResult<Vec<DomainRoute>>

List routes for a domain.

pub async fn update_route( &self, id: Uuid, tenant_id: Uuid, req: UpdateDomainRouteRequest, ) -> ProxyResult<Option<DomainRoute>>

Update a route.

pub async fn delete_route(&self, id: Uuid, tenant_id: Uuid) -> ProxyResult<bool>

Delete a route.

pub async fn create_upstream( &self, tenant_id: Uuid, req: CreateUpstreamRequest, ) -> ProxyResult<DomainUpstream>

Create an upstream for a tenant, with any backends given inline.

All or nothing: either the upstream and every backend are stored, or none of them is.

pub async fn get_upstream( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<Option<DomainUpstream>>

Get an upstream by ID.

pub async fn list_upstreams( &self, tenant_id: Uuid, ) -> ProxyResult<Vec<DomainUpstream>>

List upstreams for a tenant.

pub async fn update_upstream( &self, id: Uuid, tenant_id: Uuid, req: UpdateUpstreamRequest, ) -> ProxyResult<Option<DomainUpstream>>

Update an upstream.

pub async fn delete_upstream( &self, id: Uuid, tenant_id: Uuid, ) -> ProxyResult<bool>

Delete an upstream.

pub async fn add_backend( &self, upstream_id: Uuid, tenant_id: Uuid, req: CreateBackendRequest, ) -> ProxyResult<DomainBackend>

Add a backend to an upstream, within the per-upstream quota.

pub async fn remove_backend( &self, backend_id: Uuid, upstream_id: Uuid, tenant_id: Uuid, ) -> ProxyResult<bool>

Remove a backend from an upstream.

pub async fn get_tenant_usage( &self, tenant_id: Uuid, ) -> ProxyResult<TenantUsage>

Get tenant usage statistics.