addConnection([ 'driver' => 'sqlite', 'database' => ':memory:', ], 'default'); $capsule->setAsGlobal(); $capsule->bootEloquent(); $schema = $capsule->schema('default'); $schema->create('cloud_hosts', static function (Blueprint $table): void { $table->increments('id'); }); $schema->create('cloud_host_network_attachments', static function ( Blueprint $table ): void { $table->increments('id'); $table->integer('host_id'); $table->integer('line_id'); $table->string('network_selector'); $table->string('state'); $table->integer('priority')->default(0); }); $schema->create('cloud_public_ip_pools', static function ( Blueprint $table ): void { $table->increments('id'); $table->string('pool_key'); $table->integer('host_id'); $table->integer('network_attachment_id'); $table->integer('address_family'); $table->string('cidr'); $table->string('gateway'); $table->boolean('gateway_on_link'); $table->integer('guest_prefix_length'); $table->text('dns_servers_json'); $table->text('reserved_ips_json'); $table->string('allocation_start')->nullable(); $table->string('allocation_end')->nullable(); $table->string('allocation_cursor')->nullable(); $table->integer('max_allocations'); $table->string('state'); $table->integer('priority')->default(0); $table->integer('desired_revision'); $table->integer('observed_revision'); $table->string('sync_state'); }); $schema->create('cloud_public_ips', static function (Blueprint $table): void { $table->increments('id'); $table->integer('host_id'); $table->integer('public_ip_pool_id'); $table->integer('address_family'); $table->string('address'); $table->binary('address_binary'); $table->integer('prefix_length'); $table->string('state'); $table->integer('reservation_id')->nullable(); $table->integer('instance_id')->nullable(); $table->string('operation_id')->nullable(); $table->integer('created_at'); $table->integer('updated_at'); $table->unique(['address_family', 'address_binary']); }); $schema->create('cloud_resource_reservations', static function ( Blueprint $table ): void { $table->increments('id'); $table->integer('host_id'); $table->string('operation_id'); $table->string('state'); }); $schema->create('cloud_resource_reservation_ips', static function ( Blueprint $table ): void { $table->increments('id'); $table->integer('reservation_id'); $table->integer('address_family'); $table->integer('network_attachment_id'); $table->integer('public_ip_pool_id'); $table->integer('public_ip_id'); $table->string('operation_id'); $table->string('state'); $table->integer('created_at'); $table->integer('updated_at'); $table->integer('released_at')->nullable(); $table->string('release_reason')->default(''); $table->unique(['reservation_id', 'address_family']); }); Capsule::table('cloud_host_network_attachments')->insert([ 'id' => 10, 'host_id' => 1, 'line_id' => 7, 'network_selector' => 'bridge:br0', 'state' => 'active', 'priority' => 0, ]); Capsule::table('cloud_hosts')->insert(['id' => 1]); $common = [ 'host_id' => 1, 'network_attachment_id' => 10, 'state' => 'active', 'priority' => 0, 'desired_revision' => 1, 'observed_revision' => 1, 'sync_state' => 'applied', ]; Capsule::table('cloud_public_ip_pools')->insert([ array_merge($common, [ 'id' => 100, 'pool_key' => str_repeat('a', 32), 'address_family' => 4, 'cidr' => '8.8.8.0/24', 'gateway' => '8.8.8.1', 'gateway_on_link' => 0, 'guest_prefix_length' => 24, 'dns_servers_json' => '["1.1.1.1"]', 'reserved_ips_json' => '[]', 'allocation_start' => null, 'allocation_end' => null, 'allocation_cursor' => null, 'max_allocations' => 0, ]), array_merge($common, [ 'id' => 200, 'pool_key' => str_repeat('b', 32), 'address_family' => 6, 'cidr' => '2404:c140:156:3a::/64', 'gateway' => '2404:c140:156::1', 'gateway_on_link' => 1, 'guest_prefix_length' => 64, 'dns_servers_json' => '["2606:4700:4700::1111"]', 'reserved_ips_json' => json_encode(array_map( static fn (int $suffix): string => '2404:c140:156:3a::' . dechex($suffix), range(0x1000, 0x1013) ), JSON_THROW_ON_ERROR), 'allocation_start' => '2404:c140:156:3a::1000', 'allocation_end' => '2404:c140:156:3a::1060', 'allocation_cursor' => null, 'max_allocations' => 4, ]), ]); $now = time(); foreach ([10, 11] as $suffix) { $address = '8.8.8.' . $suffix; Capsule::table('cloud_public_ips')->insert([ 'host_id' => 1, 'public_ip_pool_id' => 100, 'address_family' => 4, 'address' => $address, 'address_binary' => inet_pton($address), 'prefix_length' => 24, 'state' => 'available', 'created_at' => $now, 'updated_at' => $now, ]); } foreach (range(0x1014, 0x102c) as $suffix) { $address = '2404:c140:156:3a::' . dechex($suffix); Capsule::table('cloud_public_ips')->insert([ 'host_id' => 1, 'public_ip_pool_id' => 200, 'address_family' => 6, 'address' => $address, 'address_binary' => inet_pton($address), 'prefix_length' => 64, 'state' => 'disabled', 'created_at' => $now, 'updated_at' => $now, ]); } $operations = [ 500 => str_repeat('c', 32), 501 => str_repeat('d', 32), 502 => str_repeat('e', 32), 503 => str_repeat('f', 32), 504 => str_repeat('9', 32), ]; foreach ($operations as $id => $operationId) { Capsule::table('cloud_resource_reservations')->insert([ 'id' => $id, 'host_id' => 1, 'operation_id' => $operationId, 'state' => 'held', ]); } $materializedBefore = Capsule::table('cloud_public_ips')->count(); $first = CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 500, $operations[500] ); $assert($first->address(4) === '8.8.8.10/24' && $first->address(6) === '2404:c140:156:3a::102d/64', 'The first atomic bundle did not contain one address from each family.'); $assert(Capsule::table('cloud_public_ips')->count() === $materializedBefore + 1, 'The sparse /64 allocator materialized more than the claimed IPv6 address.'); $assert(Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 500)->count() === 2, 'One reservation did not retain both address claims.'); $replay = CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 500, $operations[500] ); $assert(hash_equals($first->fingerprint(), $replay->fingerprint()) && Capsule::table('cloud_public_ips')->count() === $materializedBefore + 1, 'Idempotent bundle reservation allocated a second address.'); $committed = CloudPublicNetworkAllocationService::commitBundle( 500, 900, $operations[500] ); $assert(hash_equals($first->fingerprint(), $committed->fingerprint()) && Capsule::table('cloud_public_ips')->where('instance_id', 900) ->where('state', 'assigned')->count() === 2, 'Commit did not bind the complete dual-stack identity to the instance.'); $replacementAttempt = CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 500, $operations[500] ); $assert(hash_equals($committed->fingerprint(), $replacementAttempt->fingerprint()) && Capsule::table('cloud_public_ips')->count() === $materializedBefore + 1, 'A normal reservation was reused to overwrite a committed source bundle.'); $recommitted = CloudPublicNetworkAllocationService::commitBundle( 500, 900, $operations[500] ); $assert(hash_equals($committed->fingerprint(), $recommitted->fingerprint()), 'An already committed bundle was not an idempotent success.'); $rejects(static fn () => CloudPublicNetworkAllocationService::releaseBundle( 500, $operations[500], 'confirmed_not_applied', true ), 'A committed public-network bundle was released.'); $assert(Capsule::table('cloud_public_ips')->where('instance_id', 900) ->where('state', 'assigned')->count() === 2, 'Rejecting a committed release changed its assigned address bundle.'); $second = CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 501, $operations[501] ); $assert($second->address(4) === '8.8.8.11/24' && $second->address(6) === '2404:c140:156:3a::102e/64', 'The allocation cursor did not advance across a second reservation.'); CloudPublicNetworkAllocationService::fenceBundle(501, $operations[501]); $assert(Capsule::table('cloud_public_ips')->where('reservation_id', 501) ->where('state', 'uncertain')->count() === 2, 'Unknown effect did not fence both public addresses.'); $rejects(static fn () => CloudPublicNetworkAllocationService::releaseBundle( 501, $operations[501], 'confirmed_not_applied', false ), 'An unconfirmed destructive result released a public address bundle.'); CloudPublicNetworkAllocationService::releaseBundle( 501, $operations[501], 'confirmed_not_applied', true ); $assert(Capsule::table('cloud_public_ips')->where('reservation_id', 501) ->count() === 0 && Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 501)->where('state', 'released')->count() === 2, 'Confirmed non-application did not release the complete bundle.'); $uncertainSuccess = CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 504, $operations[504] ); CloudPublicNetworkAllocationService::fenceBundle(504, $operations[504]); $rejects(static fn () => CloudPublicNetworkAllocationService::commitBundle( 504, 901, str_repeat('8', 32) ), 'An uncertain bundle accepted a different operation identity.'); $recoveredSuccess = CloudPublicNetworkAllocationService::commitBundle( 504, 901, $operations[504] ); $assert(hash_equals( $uncertainSuccess->fingerprint(), $recoveredSuccess->fingerprint() ) && Capsule::table('cloud_public_ips')->where('instance_id', 901) ->where('state', 'assigned')->count() === 2 && Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 504)->where('state', 'committed')->count() === 2, 'A recovered success did not atomically commit its uncertain dual-stack bundle.'); $rejects(static fn () => CloudPublicNetworkAllocationService::commitBundle( 504, 902, $operations[504] ), 'A committed bundle was rebound to a different instance.'); Capsule::table('cloud_public_ip_pools')->where('id', 200)->update([ 'max_allocations' => 1, ]); $rejects(static fn () => CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 502, $operations[502] ), 'A reusable sparse IPv6 row bypassed the pool allocation limit.'); $assert(Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 502)->count() === 0, 'A failed upper-bound check retained a partial address claim.'); $rejects(static fn () => CloudPublicNetworkAllocationService::releaseCommittedBundle( 500, 900, $operations[500], 'instance_deleted', false ), 'An assigned bundle was released before deletion was confirmed.'); CloudPublicNetworkAllocationService::releaseCommittedBundle( 500, 900, $operations[500], 'instance_deleted', true ); $assert(Capsule::table('cloud_public_ips')->where('instance_id', 900) ->count() === 0 && Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 500)->where('state', 'released')->count() === 2, 'Confirmed instance deletion did not release its committed dual-stack bundle.'); Capsule::table('cloud_public_ip_pools')->where('id', 100)->update([ 'cidr' => '198.51.100.0/24', 'gateway' => '198.51.100.1', ]); $rejects(static fn () => CloudPublicNetworkAllocationService::reserveBundle( 1, 7, 503, $operations[503] ), 'A special-use range crossed the public-network allocator.'); $assert(Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 503)->count() === 0, 'Rejecting a non-public pool retained a partial address claim.'); $addAttachment = static function (int $id, int $hostId, int $lineId, int $priority): void { Capsule::table('cloud_host_network_attachments')->insert([ 'id' => $id, 'host_id' => $hostId, 'line_id' => $lineId, 'network_selector' => 'bridge:br' . $id, 'state' => 'active', 'priority' => $priority, ]); }; $addPool = static function (int $id, int $hostId, int $attachmentId, int $family, int $priority, string $cidr, string $gateway, ?string $rangeStart = null, ?string $rangeEnd = null, int $maximum = 0): void { Capsule::table('cloud_public_ip_pools')->insert([ 'id' => $id, 'pool_key' => str_pad(dechex($id), 32, '0', STR_PAD_LEFT), 'host_id' => $hostId, 'network_attachment_id' => $attachmentId, 'address_family' => $family, 'cidr' => $cidr, 'gateway' => $gateway, 'gateway_on_link' => $family === 6 ? 1 : 0, 'guest_prefix_length' => (int) substr(strrchr($cidr, '/'), 1), 'dns_servers_json' => $family === 6 ? '["2606:4700:4700::1111"]' : '["1.1.1.1"]', 'reserved_ips_json' => '[]', 'allocation_start' => $rangeStart, 'allocation_end' => $rangeEnd, 'allocation_cursor' => null, 'max_allocations' => $maximum, 'state' => 'active', 'priority' => $priority, 'desired_revision' => 1, 'observed_revision' => 1, 'sync_state' => 'applied', ]); }; $addIp = static function (int $hostId, int $poolId, int $family, string $address, int $prefix, string $state = 'available'): void { Capsule::table('cloud_public_ips')->insert([ 'host_id' => $hostId, 'public_ip_pool_id' => $poolId, 'address_family' => $family, 'address' => $address, 'address_binary' => inet_pton($address), 'prefix_length' => $prefix, 'state' => $state, 'reservation_id' => $state === 'assigned' ? 9999 : null, 'instance_id' => $state === 'assigned' ? 9999 : null, 'operation_id' => $state === 'assigned' ? str_repeat('7', 32) : null, 'created_at' => time(), 'updated_at' => time(), ]); }; $addReservation = static function (int $id, int $hostId, string $operationId): void { Capsule::table('cloud_resource_reservations')->insert([ 'id' => $id, 'host_id' => $hostId, 'operation_id' => $operationId, 'state' => 'held', ]); }; // A complete attachment may have more than one pool per family. Exhaustion // of a higher-priority pool must not hide capacity in its next sibling. Capsule::table('cloud_hosts')->insert(['id' => 2]); $addAttachment(20, 2, 8, 0); $addPool(110, 2, 20, 4, 0, '9.9.9.0/24', '9.9.9.1'); Capsule::table('cloud_public_ip_pools')->where('id', 110)->update([ 'reserved_ips_json' => '["9.9.9.10"]', ]); $addIp(2, 110, 4, '9.9.9.10', 24); $addPool(111, 2, 20, 4, 1, '11.0.0.0/24', '11.0.0.1'); $addIp(2, 111, 4, '11.0.0.10', 24); $addPool(210, 2, 20, 6, 0, '2404:c140:156:3b::/64', '2404:c140:156::1', '2404:c140:156:3b::10', '2404:c140:156:3b::20', 1); $addIp(2, 210, 6, '2404:c140:156:3b::10', 64, 'assigned'); $addPool(211, 2, 20, 6, 1, '2404:c140:156:3c::/64', '2404:c140:156::1', '2404:c140:156:3c::10', '2404:c140:156:3c::20', 2); $fallbackOperation = str_repeat('6', 32); $addReservation(600, 2, $fallbackOperation); $fallback = CloudPublicNetworkAllocationService::reserveBundle( 2, 8, 600, $fallbackOperation ); $assert($fallback->address(4) === '11.0.0.10/24' && $fallback->address(6) === '2404:c140:156:3c::10/64', 'Allocation did not skip exhausted higher-priority family pools.'); // The same deterministic search must continue with the next attachment when // the first complete attachment has no usable pair. $addAttachment(30, 2, 9, 0); $addPool(120, 2, 30, 4, 0, '12.0.0.0/24', '12.0.0.1'); $addIp(2, 120, 4, '12.0.0.10', 24); $addPool(220, 2, 30, 6, 0, '2404:c140:156:3d::/64', '2404:c140:156::1', '2404:c140:156:3d::10', '2404:c140:156:3d::20', 1); $addIp(2, 220, 6, '2404:c140:156:3d::10', 64, 'assigned'); $addAttachment(31, 2, 9, 1); $addPool(121, 2, 31, 4, 0, '13.0.0.0/24', '13.0.0.1'); $addIp(2, 121, 4, '13.0.0.10', 24); $addPool(221, 2, 31, 6, 0, '2404:c140:156:3e::/64', '2404:c140:156::1', '2404:c140:156:3e::10', '2404:c140:156:3e::20', 2); $attachmentFallbackOperation = str_repeat('5', 32); $addReservation(601, 2, $attachmentFallbackOperation); $attachmentFallback = CloudPublicNetworkAllocationService::reserveBundle( 2, 9, 601, $attachmentFallbackOperation ); $attachmentClaims = Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 601)->orderBy('address_family')->get(); $assert($attachmentFallback->address(4) === '13.0.0.10/24' && $attachmentFallback->address(6) === '2404:c140:156:3e::10/64' && $attachmentClaims->count() === 2 && $attachmentClaims->every( static fn ($claim): bool => (int) $claim->network_attachment_id === 31 ), 'Allocation did not continue with the next complete attachment.'); // An unavailable IPv6 leg must reject the whole bundle before the available // IPv4 leg is claimed. Capsule::table('cloud_hosts')->insert(['id' => 3]); $addAttachment(40, 3, 10, 0); $addPool(130, 3, 40, 4, 0, '14.0.0.0/24', '14.0.0.1'); $addIp(3, 130, 4, '14.0.0.10', 24); $addPool(230, 3, 40, 6, 0, '2404:c140:156:3f::/64', '2404:c140:156::1', '2404:c140:156:3f::10', '2404:c140:156:3f::20', 1); $addIp(3, 230, 6, '2404:c140:156:3f::10', 64, 'assigned'); $exhaustedOperation = str_repeat('4', 32); $addReservation(602, 3, $exhaustedOperation); $rejects(static fn () => CloudPublicNetworkAllocationService::reserveBundle( 3, 10, 602, $exhaustedOperation ), 'A host without a complete usable pool pair was accepted.'); $assert(Capsule::table('cloud_resource_reservation_ips') ->where('reservation_id', 602)->count() === 0 && Capsule::table('cloud_public_ips')->where('public_ip_pool_id', 130) ->where('state', 'available')->whereNull('reservation_id')->count() === 1, 'A failed pair selection left a partial IPv4 claim.'); echo "Atomic dual-stack public network allocation tests passed.\n";