You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
248 lines
10 KiB
PHP
248 lines
10 KiB
PHP
<?php
|
|
|
|
$root = dirname(__DIR__);
|
|
$read = static function (string $path) use ($root): string {
|
|
$source = file_get_contents($root . '/' . $path);
|
|
if (!is_string($source)) {
|
|
throw new RuntimeException('Unreadable source: ' . $path);
|
|
}
|
|
return $source;
|
|
};
|
|
$assert = static function (bool $condition, string $message): void {
|
|
if (!$condition) {
|
|
throw new RuntimeException($message);
|
|
}
|
|
};
|
|
$method = static function (string $source, string $needle): string {
|
|
$start = strpos($source, $needle);
|
|
if ($start === false) {
|
|
return '';
|
|
}
|
|
$next = strpos($source, "\n public ", $start + strlen($needle));
|
|
return $next === false ? substr($source, $start)
|
|
: substr($source, $start, $next - $start);
|
|
};
|
|
$before = static function (string $source, string $left,
|
|
string $right): bool {
|
|
$leftAt = strpos($source, $left);
|
|
$rightAt = strpos($source, $right);
|
|
return $leftAt !== false && $rightAt !== false && $leftAt < $rightAt;
|
|
};
|
|
|
|
$gate = $read('app/Services/Cloud/CloudPublicNetworkTransitionGate.php');
|
|
$jobs = $read('app/Services/Cloud/CloudJobService.php');
|
|
$worker = $read('app/Services/Cloud/CloudWorkerService.php');
|
|
$placementSource = $read('app/Services/Cloud/CloudPlacementService.php');
|
|
$restoreDeleteSource = $read(
|
|
'app/Services/Cloud/CloudPortableRestoreInstanceDeletion.php'
|
|
);
|
|
$migrationSource = $read(
|
|
'app/Services/Cloud/CloudInstanceMigrationService.php'
|
|
);
|
|
$batchSource = $read(
|
|
'app/Services/Cloud/CloudPublicIpPoolReplacementBatchService.php'
|
|
);
|
|
$batch = $method(
|
|
$batchSource,
|
|
'public static function start('
|
|
);
|
|
$workflow = $read(
|
|
'app/Services/Cloud/CloudPublicNetworkTransitionWorkflow.php'
|
|
);
|
|
$backupRestore = $method(
|
|
$read('app/Services/Cloud/CloudBackupService.php'),
|
|
'public static function restore('
|
|
);
|
|
$migration = $method(
|
|
$migrationSource,
|
|
'public static function start('
|
|
);
|
|
$placement = $method(
|
|
$placementSource,
|
|
'public static function reserveBackupRestore('
|
|
);
|
|
$placementGate = substr($placementSource, (int) strpos(
|
|
$placementSource,
|
|
'private static function assertBackupRestoreTransitionReady('
|
|
));
|
|
$migrationEnsureCleanup = $method(
|
|
$migrationSource,
|
|
'public static function ensureTargetResidueCleanup('
|
|
);
|
|
$migrationRecover = $method(
|
|
$migrationSource,
|
|
'public static function recover('
|
|
);
|
|
$migrationCleanup = $method(
|
|
$migrationSource,
|
|
'public static function cleanupRetained('
|
|
);
|
|
$networkFinalizer = $method(
|
|
$placementSource,
|
|
'public static function finishNetworkChange('
|
|
);
|
|
$enqueue = $method(
|
|
$jobs,
|
|
'public static function enqueue('
|
|
);
|
|
$forceDelete = $method(
|
|
$jobs,
|
|
'public static function enqueueForceDelete('
|
|
);
|
|
$expiryDelete = $method(
|
|
$jobs,
|
|
'public static function enqueueExpiryDelete('
|
|
);
|
|
$deletedInstance = $method(
|
|
$placementSource,
|
|
'public static function releaseDeletedInstance('
|
|
);
|
|
|
|
$assert(str_contains($gate, 'assertWriterReady')
|
|
&& str_contains($gate, 'assertPortableRestoreReady')
|
|
&& str_contains($gate, 'assertLegacyMigrationWriterRetired')
|
|
&& !str_contains($gate, 'assertMigrationReady')
|
|
&& str_contains($gate, 'assertInstanceDeleteReady'),
|
|
'Legacy-writer gate does not cover every pre-ledger writer.');
|
|
$enqueueStart = strpos($jobs, 'public static function enqueue(');
|
|
$enqueueTransaction = strpos($jobs, 'return $instance->getConnection()->transaction',
|
|
$enqueueStart === false ? 0 : $enqueueStart);
|
|
$enqueueReject = strpos($enqueue, "if (\$kind === 'network_change')");
|
|
$enqueueRejectError = strpos($enqueue, '旧公网网络写入口已停用');
|
|
$assert($enqueueStart !== false && $enqueueReject !== false
|
|
&& $enqueueRejectError !== false && $enqueueTransaction !== false
|
|
&& $enqueueReject < $enqueueTransaction
|
|
&& $enqueueRejectError < $enqueueTransaction
|
|
&& !str_contains($enqueue, 'paidNetworkChangeExpectedAmount')
|
|
&& !str_contains($enqueue, "['public_ip_cidr', 'public_pool_key'")
|
|
&& !str_contains($enqueue, '$networkLedger'),
|
|
'Ordinary enqueue retained a scalar network writer or rejects it too late.');
|
|
$assert(str_contains($worker,
|
|
"(string) \$job->kind === 'network_change'\n"
|
|
. ' && $job->public_network_transition_id === null')
|
|
&& str_contains($worker,
|
|
'CloudPublicNetworkTransitionGate::assertWriterReady()'),
|
|
'Worker does not distinguish canonical transition jobs from legacy rows.');
|
|
$assert($before($worker,
|
|
"(string) \$job->kind === 'network_change'",
|
|
"'phase' => 'dispatching'")
|
|
&& $before($worker,
|
|
"(string) \$job->kind === 'backup_restore'",
|
|
"'phase' => 'dispatching'")
|
|
&& $before($worker,
|
|
'CloudOperationRecoveryIdentity::expectedFromPayload(',
|
|
"'phase' => 'dispatching'"),
|
|
'Worker defense runs after an old operation may be dispatched.');
|
|
$restoreDispatchGate = strpos(
|
|
$worker,
|
|
'self::assertPortableRestoreDispatchReady($job, $payload)'
|
|
);
|
|
$restoreDispatchCas = strpos($worker, "'phase' => 'dispatching'");
|
|
$restoreWire = strpos(
|
|
$worker,
|
|
'self::portableRestoreDispatchPayload($job, $payload)'
|
|
);
|
|
$assert($restoreDispatchGate !== false && $restoreDispatchCas !== false
|
|
&& $restoreWire !== false
|
|
&& $restoreDispatchGate < $restoreDispatchCas
|
|
&& $restoreDispatchGate < $restoreWire
|
|
&& str_contains($worker,
|
|
'!CloudPortableRestoreFinalizer::owns($job)')
|
|
&& str_contains($worker,
|
|
"preg_match('/^[a-f0-9]{32}$/D', \$attemptKey) !== 1")
|
|
&& !str_contains($worker,
|
|
"(string) \$job->kind === 'backup_restore'\n"
|
|
. " && isset(\$payload['attempt_key'])"),
|
|
'Worker portable restore gate can be bypassed before dispatch.');
|
|
$assert(!str_contains($jobs, 'enqueuePoolReplacementNetworkChangeLocked')
|
|
&& !str_contains($batch, 'CloudPublicNetworkTransitionGate::assertWriterReady()')
|
|
&& str_contains($batchSource, 'beginPoolReplacementBatch(')
|
|
&& str_contains($workflow, 'CloudPublicNetworkTransitionBatchPlan $plan'),
|
|
'Pool replacement retained the retired scalar writer or legacy gate.');
|
|
$assert(!str_contains($backupRestore,
|
|
'CloudPublicNetworkTransitionGate::assertPortableRestoreReady()')
|
|
&& str_contains($backupRestore,
|
|
'CloudPortableRestoreRequestService::request(')
|
|
&& !str_contains($backupRestore, 'headObject(')
|
|
&& !str_contains($backupRestore, 'presignedGet(')
|
|
&& !str_contains($backupRestore, 'new CloudBackupRestore()')
|
|
&& !str_contains($backupRestore, 'reserveBackupRestore('),
|
|
'Portable-restore request seam retained the retired writer or closed gate.');
|
|
$assert(!str_contains($migration,
|
|
'CloudPublicNetworkTransitionGate::')
|
|
&& str_contains($migration, 'reserveMaintenanceMigrationTarget('),
|
|
'Canonical dual-stack migration start is still behind a legacy gate.');
|
|
$assert(str_contains($placement,
|
|
'self::assertBackupRestoreTransitionReady($restore)')
|
|
&& str_contains($placementGate,
|
|
'assertLegacyMigrationWriterRetired()')
|
|
&& str_contains($placementGate,
|
|
'CloudPublicNetworkTransitionGate::assertPortableRestoreReady()'),
|
|
'Placement lacks a defense-in-depth gate for old restore writers.');
|
|
$assert(!str_contains($migrationEnsureCleanup,
|
|
'CloudPublicNetworkTransitionGate::')
|
|
&& !str_contains($migrationRecover,
|
|
'CloudPublicNetworkTransitionGate::')
|
|
&& !str_contains($migrationCleanup,
|
|
'CloudPublicNetworkTransitionGate::')
|
|
&& str_contains($migrationEnsureCleanup, 'getConnection()->transaction')
|
|
&& str_contains($migrationRecover, 'getConnection()->transaction')
|
|
&& str_contains($migrationCleanup, 'getConnection()->transaction'),
|
|
'Canonical migration recovery is still gated or lost its transaction.');
|
|
$assert($before($networkFinalizer,
|
|
'CloudPublicNetworkTransitionGate::assertWriterReady()',
|
|
'lockForUpdate()'),
|
|
'An old network-change finalizer can mutate before its gate.');
|
|
$assert(str_contains($deletedInstance,
|
|
'CloudPublicNetworkTransitionGate::assertPortableRestoreReady()')
|
|
&& str_contains($deletedInstance,
|
|
'CloudPortableRestoreInstanceDeletion::releaseCommitted(')
|
|
&& str_contains($restoreDeleteSource,
|
|
'backup_restore_attempt_key')
|
|
&& str_contains($restoreDeleteSource,
|
|
"(string) \$attempt->state !== 'succeeded'")
|
|
&& str_contains($restoreDeleteSource,
|
|
"(string) \$attempt->effect_resolution !== 'applied'")
|
|
&& str_contains($restoreDeleteSource,
|
|
'CloudPublicNetworkAllocationService::releaseCommittedBundle(')
|
|
&& str_contains($restoreDeleteSource,
|
|
'CloudReleasedPublicNetworkBundleVerifier::verify(')
|
|
&& !str_contains($placementSource, 'releaseLockedReservation(')
|
|
&& !str_contains($placementSource, 'reservationNetworkMatches('),
|
|
'Restored-instance deletion does not distinguish legacy and attempt-owned ledgers.');
|
|
$enqueueDeleteGate = strpos(
|
|
$enqueue,
|
|
'CloudPublicNetworkTransitionGate::assertInstanceDeleteReady('
|
|
);
|
|
$enqueueTransaction = strpos($enqueue, 'getConnection()->transaction');
|
|
$enqueueInstanceLock = strpos($enqueue, "CloudInstance::where('id'");
|
|
$enqueueLockedDeleteGate = $enqueueInstanceLock === false ? false : strpos(
|
|
$enqueue,
|
|
'CloudPublicNetworkTransitionGate::assertInstanceDeleteReady(',
|
|
$enqueueInstanceLock
|
|
);
|
|
$enqueueJob = strpos($enqueue, 'new CloudJob()');
|
|
$assert($enqueueDeleteGate !== false && $enqueueTransaction !== false
|
|
&& $enqueueDeleteGate < $enqueueTransaction
|
|
&& $enqueueLockedDeleteGate !== false && $enqueueJob !== false
|
|
&& $enqueueLockedDeleteGate < $enqueueJob,
|
|
'Restored-instance delete gate can run after durable job creation.');
|
|
$assert($before($forceDelete,
|
|
'CloudPublicNetworkTransitionGate::assertInstanceDeleteReady(',
|
|
'new CloudJob()'),
|
|
'Restored-instance force-delete gate runs after durable job creation.');
|
|
$assert($before($expiryDelete,
|
|
'CloudPublicNetworkTransitionGate::assertInstanceDeleteReady(',
|
|
'new CloudJob()'),
|
|
'Restored-instance expiry-delete gate runs after durable job creation.');
|
|
$workerDeleteGate = strpos(
|
|
$worker,
|
|
'assertInstanceDeleteReady($deleteInstance)'
|
|
);
|
|
$workerDispatch = strpos($worker, "'phase' => 'dispatching'");
|
|
$assert($workerDeleteGate !== false && $workerDispatch !== false
|
|
&& $workerDeleteGate < $workerDispatch,
|
|
'Worker can dispatch a restored-instance delete before its gate.');
|
|
|
|
echo "Legacy public-network writer gate contracts passed.\n";
|