$instanceId, 'actor_id' => $actorId, 'request_key' => $requestKey, 'family' => $family, 'pool_key' => str_repeat($poolCharacter, 32), 'address_cidr' => $address . ($family === 4 ? '/29' : '/64'), ]; }; $allocator = static function (int $reservationId): array { return [ 'reservation_id' => $reservationId, 'operation_id' => str_pad( dechex($reservationId), 32, '0', STR_PAD_LEFT ), ]; }; $reservationAddress = static function ( int $reservationId, int $family ): ?string { $address = Capsule::table('cloud_resource_reservation_ips as claim') ->join( 'cloud_public_ips as ip', 'ip.id', '=', 'claim.public_ip_id' )->where('claim.reservation_id', $reservationId) ->where('claim.address_family', $family) ->where('claim.active_claim', 1)->value('ip.address'); return is_string($address) ? $address : null; }; $tenant = static fn (string $requestKey): array => [ 'instance_id' => 101, 'actor_id' => 10, 'request_key' => $requestKey, 'expected_amount' => '5.00', ]; $batch = static fn (int $actorId, string $requestKey): array => [ 'actor_id' => $actorId, 'request_key' => $requestKey, 'source_pool_key' => str_repeat('a', 32), 'target_pool_key' => str_repeat('c', 32), 'source_revision' => 11, 'target_revision' => 13, ]; $assertWinnerLoser = static function ( array $winner, array $loser, string $context ): void { mysqlConcurrencyAssert(($winner['ok'] ?? false) === true, $context . ': expected winner failed.'); mysqlConcurrencyAssert(($loser['ok'] ?? true) === false && (int) ($loser['http_status'] ?? 0) === 409, $context . ': expected loser was not rejected with 409.'); }; try { // Scenario 1: different actors contend on one instance. Both possible // winners are exercised; the loser must leave finance and IPAM untouched. $adminPayload = $admin( 99, 'mysql-admin-wins-0001', 'c', '8.8.9.2' ); $expected = $oracle('admin_begin', $adminPayload); $reset(); [$adminWin, $tenantLose] = $race( 'admin_begin', $adminPayload, 'user_begin', $tenant('mysql-tenant-loses-0001') ); $assertWinnerLoser($adminWin, $tenantLose, 'admin versus tenant'); mysqlConcurrencyAssertTransitionResponseOperation( $adminWin, 'admin versus tenant winner' ); mysqlConcurrencyAssert( Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_jobs')->count() === 1 && Capsule::table('cloud_invoices')->count() === 0 && (string) Capsule::table('user')->where('id', 10) ->value('money') === '20.00', 'Rejected tenant mutation changed finance or transition state.' ); mysqlConcurrencyAssertCanonical($expected, 'admin versus tenant'); mysqlConcurrencyAssertLedger(); $tenantPayload = $tenant('mysql-tenant-wins-0001'); $expected = $oracle('user_begin', $tenantPayload); $reset(); [$tenantWin, $adminLose] = $race( 'user_begin', $tenantPayload, 'admin_begin', $admin(99, 'mysql-admin-loses-0001', 'c', '8.8.9.2') ); $assertWinnerLoser($tenantWin, $adminLose, 'tenant versus admin'); mysqlConcurrencyAssertTransitionResponseOperation( $tenantWin, 'tenant versus admin winner' ); mysqlConcurrencyAssert( Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_jobs')->count() === 1 && Capsule::table('cloud_invoices')->count() === 1 && (string) Capsule::table('user')->where('id', 10) ->value('money') === '15.00', 'Winning tenant mutation was not charged exactly once.' ); mysqlConcurrencyAssertCanonical($expected, 'tenant versus admin'); mysqlConcurrencyAssertLedger(); // Scenario 2: exact duplicate replays one generation; same idempotency // key with a different immutable target is rejected with zero extra rows. $same = $admin(99, 'mysql-exact-replay-0001', 'c', '8.8.9.2'); $expected = $oracle('admin_begin', $same); $reset(); [$first, $replay] = $race( 'admin_begin', $same, 'admin_begin', $same ); mysqlConcurrencyAssert(($first['ok'] ?? false) === true && ($replay['ok'] ?? false) === true, 'Exact duplicate did not return two successful responses.'); $firstOperationId = mysqlConcurrencyAssertTransitionResponseOperation( $first, 'exact replay first response' ); $replayOperationId = mysqlConcurrencyAssertTransitionResponseOperation( $replay, 'exact replay second response' ); $replayFlags = [ (bool) ($first['result']['replayed'] ?? null), (bool) ($replay['result']['replayed'] ?? null), ]; sort($replayFlags); mysqlConcurrencyAssert( (int) $first['result']['transition_id'] === (int) $replay['result']['transition_id'] && (int) $first['result']['job_id'] === (int) $replay['result']['job_id'] && $first['result']['operation_id'] === $replay['result']['operation_id'] && hash_equals($firstOperationId, $replayOperationId) && $replayFlags === [false, true] && Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_jobs')->count() === 1, 'Exact replay duplicated or changed the durable generation.' ); mysqlConcurrencyAssertCanonical($expected, 'exact idempotent replay'); mysqlConcurrencyAssertLedger(); $conflictWinnerPayload = $admin( 99, 'mysql-key-conflict-0001', 'c', '8.8.9.2' ); $conflictOtherPayload = $admin( 99, 'mysql-key-conflict-0001', 'e', '8.8.10.2' ); $expectedConflictA = $oracle( 'admin_begin', $conflictWinnerPayload ); $expectedConflictB = $oracle( 'admin_begin', $conflictOtherPayload ); $reset(); [$conflictA, $conflictB] = $race( 'admin_begin', $conflictWinnerPayload, 'admin_begin', $conflictOtherPayload ); // The actor-row release is unbiased: either conflicting payload may win. // Its matching sequential oracle must describe the durable result. if (($conflictA['ok'] ?? false) === true) { $conflictWinner = $conflictA; $conflictLoser = $conflictB; $expected = $expectedConflictA; } else { $conflictWinner = $conflictB; $conflictLoser = $conflictA; $expected = $expectedConflictB; } $assertWinnerLoser($conflictWinner, $conflictLoser, 'idempotency target conflict'); mysqlConcurrencyAssertTransitionResponseOperation( $conflictWinner, 'idempotency target-conflict winner' ); mysqlConcurrencyAssert( Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_jobs')->count() === 1, 'Conflicting replay left more than one durable generation.' ); mysqlConcurrencyAssertCanonical($expected, 'idempotency target conflict'); mysqlConcurrencyAssertLedger(); // Scenario 3: a batch and a single transition serialize on the same // instance. Whichever owns the instance first wins without partial batch // rows or sibling transitions from the loser. $singlePayload = $admin( 99, 'mysql-single-wins-0001', 'e', '8.8.10.2' ); $expected = $oracle('admin_begin', $singlePayload); $reset(); [$singleWin, $batchLose] = $race( 'admin_begin', $singlePayload, 'batch_begin', $batch(98, 'mysql-batch-loses-0001') ); $assertWinnerLoser($singleWin, $batchLose, 'single versus batch'); mysqlConcurrencyAssertTransitionResponseOperation( $singleWin, 'single versus batch winner' ); mysqlConcurrencyAssert( Capsule::table('cloud_public_ip_pool_replacement_batches')->count() === 0 && Capsule::table('cloud_public_ip_pool_replacement_batch_items') ->count() === 0 && Capsule::table('cloud_public_network_transitions')->count() === 1, 'Rejected batch left a parent, item, or sibling transition.' ); mysqlConcurrencyAssertCanonical($expected, 'single versus batch'); mysqlConcurrencyAssertLedger(); $batchPayload = $batch(98, 'mysql-batch-wins-0001'); $expected = $oracle('batch_begin', $batchPayload); $reset(); [$batchWin, $singleLose] = $race( 'batch_begin', $batchPayload, 'admin_begin', $admin(99, 'mysql-single-loses-0001', 'e', '8.8.10.2') ); $assertWinnerLoser($batchWin, $singleLose, 'batch versus single'); mysqlConcurrencyAssertBatchResponseOperation( $batchWin, 'batch versus single winner' ); mysqlConcurrencyAssert( Capsule::table('cloud_public_ip_pool_replacement_batches')->count() === 1 && Capsule::table('cloud_public_ip_pool_replacement_batch_items') ->count() === 2 && Capsule::table('cloud_public_network_transitions')->count() === 2 && Capsule::table('cloud_jobs')->count() === 3, 'Winning batch did not create one atomic parent and two children.' ); mysqlConcurrencyAssertCanonical($expected, 'batch versus single'); mysqlConcurrencyAssertLedger(); // Scenario 4: two first-time allocators contend on one sparse dual-stack // catalog. Both reservations must commit a complete and unique pair. $reset(); [$allocatorA, $allocatorB] = $hostRace( 'reserve_bundle', $allocator(2001), 'reserve_bundle', $allocator(2002) ); mysqlConcurrencyAssert( ($allocatorA['ok'] ?? false) === true && ($allocatorB['ok'] ?? false) === true && (int) ($allocatorA['result']['reservation_id'] ?? 0) === 2001 && (int) ($allocatorB['result']['reservation_id'] ?? 0) === 2002, 'allocator versus allocator did not reserve both bundles.' ); $allocatedV4 = [ $reservationAddress(2001, 4), $reservationAddress(2002, 4), ]; $allocatedV6 = [ $reservationAddress(2001, 6), $reservationAddress(2002, 6), ]; sort($allocatedV4); sort($allocatedV6); mysqlConcurrencyAssert( $allocatedV4 === ['8.8.8.4', '8.8.8.5'] && $allocatedV6 === [ '2404:c140:156:3a::1002', '2404:c140:156:3a::1003', ] && (string) Capsule::table('cloud_public_ip_pools') ->where('id', 12)->value('allocation_cursor') === '2404:c140:156:3a::1004' && Capsule::table('cloud_public_network_transitions')->count() === 0 && Capsule::table('cloud_jobs')->count() === 0, 'allocator versus allocator produced duplicate or partial capacity.' ); mysqlConcurrencyAssertLedger(); // Scenario 5: first-time allocation and an exact sparse IPv6 transition // contend for ::1002. Allocation always succeeds; the transition either // owns ::1002 first or is rejected after the allocator owns it. $reset(); [$allocatorResult, $transitionResult] = $hostRace( 'reserve_bundle', $allocator(2001), 'admin_begin', $admin( 99, 'mysql-allocator-v6-race-0001', 'b', '2404:c140:156:3a::1002', 6 ) ); mysqlConcurrencyAssert( ($allocatorResult['ok'] ?? false) === true && (int) ($allocatorResult['result']['reservation_id'] ?? 0) === 2001, 'allocator versus exact IPv6 transition lost the complete bundle.' ); $allocatorV6 = $reservationAddress(2001, 6); $exactRows = Capsule::table('cloud_public_ips') ->where('address_family', 6) ->where('address_binary', inet_pton('2404:c140:156:3a::1002')) ->get(); mysqlConcurrencyAssert( $exactRows->count() === 1, 'allocator versus exact IPv6 transition duplicated ::1002.' ); if (($transitionResult['ok'] ?? false) === true) { mysqlConcurrencyAssertTransitionResponseOperation( $transitionResult, 'allocator versus exact IPv6 transition winner' ); mysqlConcurrencyAssert( $allocatorV6 === '2404:c140:156:3a::1003' && (string) Capsule::table('cloud_public_ip_pools') ->where('id', 12)->value('allocation_cursor') === '2404:c140:156:3a::1004' && Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_jobs')->count() === 1, 'Exact IPv6 winner did not move the allocator past ::1002.' ); } else { mysqlConcurrencyAssert( (int) ($transitionResult['http_status'] ?? 0) === 409 && $allocatorV6 === '2404:c140:156:3a::1002' && (string) Capsule::table('cloud_public_ip_pools') ->where('id', 12)->value('allocation_cursor') === '2404:c140:156:3a::1003' && Capsule::table('cloud_public_network_transitions')->count() === 0 && Capsule::table('cloud_jobs')->count() === 0, 'Allocator winner left exact-transition residue or wrong cursor.' ); } mysqlConcurrencyAssertLedger(); // Scenario 6: two distinct instances request the same exact sparse IPv6 // address. Exactly one durable transition may own the target generation. $reset(); [$exactA, $exactB] = $hostRace( 'admin_begin', $admin( 99, 'mysql-same-v6-instance-a-0001', 'b', '2404:c140:156:3a::1002', 6, 101 ), 'admin_begin', $admin( 98, 'mysql-same-v6-instance-b-0001', 'b', '2404:c140:156:3a::1002', 6, 102 ) ); if (($exactA['ok'] ?? false) === true) { $exactWinner = $exactA; $exactLoser = $exactB; $winningInstanceId = 101; } else { $exactWinner = $exactB; $exactLoser = $exactA; $winningInstanceId = 102; } $assertWinnerLoser( $exactWinner, $exactLoser, 'two transitions request the same exact IPv6' ); mysqlConcurrencyAssertTransitionResponseOperation( $exactWinner, 'same exact IPv6 winner' ); $exactIp = Capsule::table('cloud_public_ips') ->where('address_family', 6) ->where('address_binary', inet_pton('2404:c140:156:3a::1002')) ->first(); mysqlConcurrencyAssert( Capsule::table('cloud_public_network_transitions')->count() === 1 && Capsule::table('cloud_public_network_transitions') ->where('instance_id', $winningInstanceId)->count() === 1 && Capsule::table('cloud_jobs')->count() === 1 && Capsule::table('cloud_resource_reservation_ips') ->whereIn('reservation_id', [1001, 1002]) ->where('address_family', 6) ->where('state', 'reserved') ->whereNull('active_claim')->count() === 1 && $exactIp !== null && (string) $exactIp->state === 'reserved' && $exactIp->instance_id === null && (string) Capsule::table('cloud_public_ip_pools') ->where('id', 12)->value('allocation_cursor') === '2404:c140:156:3a::1002', 'Same exact IPv6 race left more than one generation or loser residue.' ); mysqlConcurrencyAssertLedger(); echo "Cloud public-network MySQL concurrency scenarios passed.\n"; echo "C11 will extend this harness with Worker-finalizer and unknown-effect recovery races.\n"; } finally { foreach (['*.go', '*.entered', '*.tmp-*'] as $pattern) { foreach (glob($barrierDirectory . '/' . $pattern) ?: [] as $barrier) { if (is_file($barrier)) { unlink($barrier); } } } if (is_dir($barrierDirectory)) { rmdir($barrierDirectory); } if ($createdKey && is_file($keyFile)) { unlink($keyFile); } }