fix(certificates): do not verify DNS again for a job the endpoint just verified

The proxy create and re-verify endpoints run the multi-region DNS validator,
write the rule as verifying and enqueue generation. The worker then ran the
identical validator again seconds later: doubled DNS traffic when both pass,
and when the second run failed on a transient it wrote unverified over a
status the endpoint had just written. The certificate message now carries
skipDomainValidation, set by every enqueuer that verified DNS itself, and
the worker honours it. The renew check stays in place, unlike a forced job.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Matej BačoandClaude Fable 5.1 committed 2026-09-18 18:48:13 +02:00
1 parent f61009be8c
commit 21b634f3da
9 files changed
+233 -5

No files matched your search

@@ -12,6 +12,12 @@ final class Certificate extends Base
public readonly bool $skipRenewCheck = false,
public readonly ?string $validationDomain = null,
public readonly string $action = \Appwrite\Event\Certificate::ACTION_GENERATION,
/**
* The enqueuer verified the domain's DNS itself, moments before enqueueing,
* so the worker does not verify it again. Unlike `skipRenewCheck` this
* leaves the renew check in place.
*/
public readonly bool $skipDomainValidation = false,
) {
}
@@ -27,6 +33,7 @@ final class Certificate extends Base
'skipRenewCheck' => $this->skipRenewCheck,
'validationDomain' => $this->validationDomain,
'action' => $this->action,
'skipDomainValidation' => $this->skipDomainValidation,
];
}
@@ -38,6 +45,7 @@ final class Certificate extends Base
skipRenewCheck: $data['skipRenewCheck'] ?? false,
validationDomain: $data['validationDomain'] ?? null,
action: $data['action'] ?? \Appwrite\Event\Certificate::ACTION_GENERATION,
skipDomainValidation: $data['skipDomainValidation'] ?? false,
);
}
}
@@ -134,6 +134,8 @@ class Create extends Action
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
action: \Appwrite\Event\Certificate::ACTION_GENERATION,
// verifyRule() above passed, which is what put the rule in this status.
skipDomainValidation: true,
));
}
@@ -162,6 +162,8 @@ class Create extends Action
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
action: \Appwrite\Event\Certificate::ACTION_GENERATION,
// A rule reaches this status only through verifyRule() above.
skipDomainValidation: $rule->getAttribute('status', '') === RULE_STATUS_CERTIFICATE_GENERATING,
));
}
@@ -178,6 +178,8 @@ class Create extends Action
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
action: \Appwrite\Event\Certificate::ACTION_GENERATION,
// verifyRule() above passed, which is what put the rule in this status.
skipDomainValidation: true,
));
}
@@ -162,6 +162,8 @@ class Create extends Action
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
action: \Appwrite\Event\Certificate::ACTION_GENERATION,
// A rule reaches this status only through verifyRule() above.
skipDomainValidation: $rule->getAttribute('status', '') === RULE_STATUS_CERTIFICATE_GENERATING,
));
}
@@ -116,13 +116,15 @@ class Update extends Action
throw $err;
}
// Issue a TLS certificate when DNS verification is successful
// Issue a TLS certificate when DNS verification is successful. The worker
// does not verify DNS again: verifyRule() above just did.
$publisherForCertificates->enqueue(new \Appwrite\Event\Message\Certificate(
project: $project,
domain: new Document([
'domain' => $rule->getAttribute('domain'),
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
skipDomainValidation: true,
));
if (!empty($certificate)) {
+13 -4
View File
@@ -108,6 +108,7 @@ class Certificates extends Action
$domain = new Domain($document->getAttribute('domain', ''));
$domainType = $document->getAttribute('domainType');
$skipRenewCheck = $certificateMessage->skipRenewCheck;
$skipDomainValidation = $certificateMessage->skipDomainValidation;
$validationDomain = $certificateMessage->validationDomain;
$action = $certificateMessage->action;
@@ -119,7 +120,7 @@ class Certificates extends Action
break;
case \Appwrite\Event\Certificate::ACTION_GENERATION:
$this->handleCertificateGenerationAction($domain, $domainType, $dbForPlatform, $publisherForMails, $queueForEvents, $queueForWebhooks, $publisherForFunctions, $queueForRealtime, $certificates, $authorization, $bus, $skipRenewCheck, $plan, $validationDomain);
$this->handleCertificateGenerationAction($domain, $domainType, $dbForPlatform, $publisherForMails, $queueForEvents, $queueForWebhooks, $publisherForFunctions, $queueForRealtime, $certificates, $authorization, $bus, $skipRenewCheck, $plan, $validationDomain, $skipDomainValidation);
break;
default:
@@ -201,6 +202,7 @@ class Certificates extends Action
'domainType' => $rule->getAttribute('deploymentResourceType', $rule->getAttribute('type')),
]),
action: \Appwrite\Event\Certificate::ACTION_GENERATION,
skipDomainValidation: true,
));
Console::success('Certificate generation triggered successfully.');
@@ -221,6 +223,7 @@ class Certificates extends Action
* @param bool $skipRenewCheck
* @param array $plan
* @param string|null $validationDomain
* @param bool $skipDomainValidation The enqueuer verified DNS itself moments ago
* @return void
* @throws Authorization
* @throws Conflict
@@ -244,7 +247,8 @@ class Certificates extends Action
Bus $bus,
bool $skipRenewCheck = false,
array $plan = [],
?string $validationDomain = null
?string $validationDomain = null,
bool $skipDomainValidation = false
): void {
/**
* 1. Read arguments and validate domain
@@ -310,9 +314,14 @@ class Certificates extends Action
// Ensure certificate is associated with the rule
$rule->setAttribute('certificateId', $certificate->getId());
// Validate domain and DNS records. Skip if job is forced
// Validate domain and DNS records. Skip if job is forced, or if the
// enqueuer verified DNS itself moments ago: a second run of the same
// check can only agree, or fail on a transient and contradict the
// status the enqueuer just wrote.
if (!$skipRenewCheck) {
$this->validateDomain($rule, $domain, $validationDomain);
if (!$skipDomainValidation) {
$this->validateDomain($rule, $domain, $validationDomain);
}
// If certificate exists already, double-check expiry date. Skip if job is forced
if (!$certificates->isRenewRequired($domain->get(), $domainType)) {
@@ -0,0 +1,46 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Event\Message;
use Appwrite\Event\Certificate as CertificateEvent;
use Appwrite\Event\Message\Certificate as CertificateMessage;
use PHPUnit\Framework\TestCase;
use Utopia\Database\Document;
require_once __DIR__ . '/../../../../app/init.php';
final class CertificateTest extends TestCase
{
public function testSkipDomainValidationRoundTripsThroughTheQueuePayload(): void
{
$message = new CertificateMessage(
project: new Document(['$id' => 'project-1', '$sequence' => '1']),
domain: new Document(['domain' => 'www.example.com', 'domainType' => 'site']),
action: CertificateEvent::ACTION_GENERATION,
skipDomainValidation: true,
);
$restored = CertificateMessage::fromArray($message->toArray());
$this->assertTrue($restored->skipDomainValidation);
// The renew check is a separate decision and stays in place.
$this->assertFalse($restored->skipRenewCheck);
$this->assertSame('www.example.com', $restored->domain->getAttribute('domain'));
}
public function testAPayloadFromBeforeTheFlagStillValidatesTheDomain(): void
{
// Jobs already sitting in the queue when this ships carry no key.
$restored = CertificateMessage::fromArray([
'project' => ['$id' => 'project-1', '$sequence' => '1', 'database' => ''],
'domain' => ['domain' => 'www.example.com', 'domainType' => 'site'],
'skipRenewCheck' => false,
'validationDomain' => null,
'action' => CertificateEvent::ACTION_GENERATION,
]);
$this->assertFalse($restored->skipDomainValidation);
}
}
@@ -0,0 +1,155 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Workers;
use Appwrite\Event\Certificate as CertificateEvent;
use Appwrite\Event\Event;
use Appwrite\Event\Message\Certificate as CertificateMessage;
use Appwrite\Event\Publisher\Certificate as CertificatePublisher;
use Appwrite\Event\Publisher\Func as FunctionPublisher;
use Appwrite\Event\Publisher\Mail as MailPublisher;
use Appwrite\Event\Realtime;
use Appwrite\Event\Webhook;
use Appwrite\Platform\Workers\Certificates;
use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
use PHPUnit\Framework\MockObject\Stub;
use PHPUnit\Framework\TestCase;
use Tests\Unit\Event\MockPublisher;
use Utopia\Bus\Bus;
use Utopia\Cdn\Certificates\Provider;
use Utopia\Database\Database;
use Utopia\Database\DateTime;
use Utopia\Database\Document;
use Utopia\Database\Validator\Authorization;
use Utopia\Queue\Message;
use Utopia\Queue\Queue;
require_once __DIR__ . '/../../../app/init.php';
/**
* The proxy endpoints verify a domain's DNS before they enqueue generation.
* The worker ran the same check again seconds later, and a transient failure
* there wrote `unverified` over a status the endpoint had just written. The
* domain here sits under a TLD no public suffix list knows, which the check
* refuses before touching the network, so what the tests observe is whether
* the check ran: a job that reaches issuance skipped it, a job that fails the
* rule did not.
*/
#[AllowMockObjectsWithoutExpectations]
final class CertificatesDomainValidationTest extends TestCase
{
private const DOMAIN = 'www.example.invalid';
public function testAJobFromAVerifiedEndpointReachesIssuanceWithoutASecondDnsCheck(): void
{
$certificates = $this->createMock(Provider::class);
$certificates->method('isRenewRequired')->willReturn(true);
$certificates->method('isInstantGeneration')->willReturn(false);
$certificates->expects($this->once())->method('issueCertificate');
$writes = $this->generate($certificates, skipDomainValidation: true);
$this->assertSame(RULE_STATUS_CERTIFICATE_GENERATING, $writes['rules']['status']);
}
public function testTheRenewCheckStaysInPlaceWhenOnlyDomainValidationIsSkipped(): void
{
// Unlike a forced job, this one still asks whether a renewal is needed.
$certificates = $this->createMock(Provider::class);
$certificates->method('isRenewRequired')->willReturn(false);
$certificates->expects($this->never())->method('issueCertificate');
$writes = $this->generate($certificates, skipDomainValidation: true);
$this->assertSame(RULE_STATUS_CERTIFICATE_GENERATING, $writes['rules']['status']);
}
public function testAJobWithoutTheFlagStillChecksDns(): void
{
$certificates = $this->createMock(Provider::class);
$certificates->expects($this->never())->method('issueCertificate');
$writes = $this->generate($certificates, skipDomainValidation: false);
$this->assertSame(RULE_STATUS_CERTIFICATE_GENERATION_FAILED, $writes['rules']['status']);
}
/**
* Runs one generation job for a rule in `verifying`.
*
* @return array<string, array<string, mixed>> the attributes written per collection
*/
private function generate(Provider&Stub $certificates, bool $skipDomainValidation): array
{
$rule = new Document([
'$id' => md5(self::DOMAIN),
'$collection' => 'rules',
'domain' => self::DOMAIN,
'type' => 'deployment',
'deploymentResourceType' => 'site',
'status' => RULE_STATUS_CERTIFICATE_GENERATING,
'owner' => '',
'certificateId' => 'cert-1',
'projectId' => 'project-1',
'projectInternalId' => '1',
]);
$certificate = new Document([
'$id' => 'cert-1',
'$collection' => 'certificates',
'$updatedAt' => DateTime::now(),
'domain' => self::DOMAIN,
'attempts' => 0,
'logs' => '',
]);
$writes = [];
$dbForPlatform = $this->createStub(Database::class);
$dbForPlatform->method('getDocument')
->willReturnCallback(fn (string $collection, string $id): Document => match ($collection) {
'rules' => $rule,
'certificates' => $certificate,
// No project row: the event fan-out stops there.
default => new Document(),
});
$dbForPlatform->method('findOne')->willReturn($rule);
$dbForPlatform->method('updateDocument')
->willReturnCallback(function (string $collection, string $id, Document $document) use (&$writes): Document {
$writes[$collection] = $document->getArrayCopy();
return new Document(\array_merge(['$id' => $id], $document->getArrayCopy()));
});
$message = (new Message())->setPayload((new CertificateMessage(
project: new Document(['$id' => 'project-1', '$sequence' => '1']),
domain: new Document(['domain' => self::DOMAIN, 'domainType' => 'site']),
action: CertificateEvent::ACTION_GENERATION,
skipDomainValidation: $skipDomainValidation,
))->toArray());
try {
(new Certificates())->action(
$message,
$dbForPlatform,
new MailPublisher(new MockPublisher(), new Queue('v1-mails')),
$this->createStub(Event::class),
$this->createStub(Webhook::class),
new FunctionPublisher(new MockPublisher(), new Queue('v1-functions')),
$this->createStub(Realtime::class),
new CertificatePublisher(new MockPublisher(), new Queue('v1-certificates')),
$certificates,
[],
$this->createStub(Authorization::class),
(new Bus())->setResolver(static fn (): null => null),
);
} catch (\Throwable) {
// The worker rethrows an issuance failure after recording it; the
// records are what these tests read.
}
return $writes;
}
}