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.
272 lines
11 KiB
PHP
272 lines
11 KiB
PHP
<?php
|
|
|
|
namespace App\Services {
|
|
final class Config
|
|
{
|
|
public static array $values = [
|
|
'cloud_engine_url' => 'http://127.0.0.1:8000',
|
|
'super_admin' => '99',
|
|
];
|
|
|
|
public static function get($name, $default = null)
|
|
{
|
|
return self::$values[$name] ?? $default;
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace App\Services\Cloud {
|
|
final class CloudSecrets
|
|
{
|
|
public static function key(string $purpose): string
|
|
{
|
|
return str_repeat('k', 32);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
require dirname(__DIR__) . '/vendor/autoload.php';
|
|
|
|
use App\Models\CloudHost;
|
|
use App\Models\CloudHostCapacitySnapshot;
|
|
use App\Models\CloudPublicIp;
|
|
use App\Models\User;
|
|
use App\Services\Cloud\CloudEngineClient;
|
|
use App\Services\Cloud\CloudHostInventorySyncService;
|
|
use GuzzleHttp\Client;
|
|
use GuzzleHttp\Handler\MockHandler;
|
|
use GuzzleHttp\HandlerStack;
|
|
use GuzzleHttp\Middleware;
|
|
use GuzzleHttp\Psr7\Response;
|
|
use Illuminate\Database\Capsule\Manager as Capsule;
|
|
use Illuminate\Database\Schema\Blueprint;
|
|
|
|
$assert = static function ($condition, string $message): void {
|
|
if (!$condition) {
|
|
throw new RuntimeException($message);
|
|
}
|
|
};
|
|
$json = static fn (array $value): string => json_encode(
|
|
$value, JSON_THROW_ON_ERROR | JSON_UNESCAPED_SLASHES
|
|
);
|
|
$capacity = static function (int $observedAt, int $cpu = 16): array {
|
|
return [
|
|
'health' => 'healthy',
|
|
'observed_at' => $observedAt,
|
|
'instances' => ['total' => 3, 'running' => 2],
|
|
'cpu' => ['total' => $cpu, 'allocated' => 4,
|
|
'available' => max(0, $cpu - 4)],
|
|
'memory_mib' => ['total' => 32768, 'allocated' => 8192,
|
|
'available' => 24576],
|
|
'storage_bytes' => ['total' => 1099511627776,
|
|
'allocated' => 274877906944, 'available' => 824633720832],
|
|
'public_ipv4' => ['configured' => true, 'total' => 6,
|
|
'reserved' => 1, 'allocated' => 2, 'available' => 3],
|
|
];
|
|
};
|
|
$network = static function (int $count = 3): array {
|
|
return [
|
|
'configuration_state' => 'ready',
|
|
'pool_cidr' => '8.8.8.0/29',
|
|
'guest_prefix' => 29,
|
|
'gateway' => '8.8.8.1',
|
|
'dns_servers' => ['1.1.1.1'],
|
|
'available_ips' => ['8.8.8.3/29', '8.8.8.5/29', '8.8.8.6/29'],
|
|
'available_count' => $count,
|
|
'message' => 'validated test response',
|
|
];
|
|
};
|
|
$client = static function (array $responses, ?array &$history = null): CloudEngineClient {
|
|
$stack = HandlerStack::create(new MockHandler($responses));
|
|
if ($history !== null) {
|
|
$stack->push(Middleware::history($history));
|
|
}
|
|
return new CloudEngineClient(new Client(['handler' => $stack]), 3.0);
|
|
};
|
|
|
|
$capsule = new Capsule();
|
|
$capsule->addConnection(['driver' => 'sqlite', 'database' => ':memory:'], 'default');
|
|
$capsule->setAsGlobal();
|
|
$capsule->bootEloquent();
|
|
$schema = $capsule->schema('default');
|
|
$schema->create('user', function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->integer('enable')->default(1);
|
|
$table->integer('is_admin')->default(0);
|
|
});
|
|
$schema->create('cloud_hosts', function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->string('name');
|
|
$table->integer('enabled')->default(0);
|
|
$table->string('health_state')->default('unknown');
|
|
$table->integer('last_seen_at')->nullable();
|
|
$table->integer('health_checked_at')->nullable();
|
|
$table->string('health_error_code')->default('');
|
|
$table->integer('created_at');
|
|
$table->integer('updated_at');
|
|
});
|
|
$schema->create('cloud_host_capacity_snapshots', function (Blueprint $table): void {
|
|
$table->integer('host_id')->primary();
|
|
foreach (['cpu_total_cores', 'cpu_allocated_cores', 'cpu_available_cores',
|
|
'memory_total_mib', 'memory_allocated_mib', 'memory_available_mib',
|
|
'storage_total_bytes', 'storage_allocated_bytes', 'storage_available_bytes',
|
|
'instance_total_count', 'instance_running_count',
|
|
'public_ip_total_count', 'public_ip_reserved_count',
|
|
'public_ip_allocated_count', 'public_ip_available_count',
|
|
'observed_at', 'last_attempt_at', 'revision'] as $field) {
|
|
$table->integer($field)->default(0);
|
|
}
|
|
$table->integer('public_ip_configured')->default(0);
|
|
$table->string('sync_state')->default('never');
|
|
$table->string('last_error_code')->default('');
|
|
$table->integer('created_at');
|
|
$table->integer('updated_at');
|
|
});
|
|
$schema->create('cloud_public_ips', function (Blueprint $table): void {
|
|
$table->increments('id');
|
|
$table->integer('host_id');
|
|
$table->string('address')->unique();
|
|
$table->integer('prefix_length');
|
|
$table->string('state')->default('available');
|
|
$table->integer('reservation_id')->nullable();
|
|
$table->integer('instance_id')->nullable();
|
|
$table->string('operation_id')->nullable();
|
|
$table->integer('created_at');
|
|
$table->integer('updated_at');
|
|
});
|
|
|
|
$admin = new User();
|
|
$admin->id = 99;
|
|
$admin->enable = 1;
|
|
$admin->is_admin = 1;
|
|
$admin->save();
|
|
$host = new CloudHost();
|
|
$host->name = 'test-host';
|
|
$host->enabled = 1;
|
|
$host->health_state = 'unknown';
|
|
$host->health_error_code = '';
|
|
$host->created_at = 900;
|
|
$host->updated_at = 900;
|
|
$host->save();
|
|
|
|
$insertIp = static function (string $address, string $state,
|
|
?int $reservationId = null, ?int $instanceId = null): void {
|
|
$row = new CloudPublicIp();
|
|
$row->host_id = 1;
|
|
$row->address = $address;
|
|
$row->prefix_length = 29;
|
|
$row->state = $state;
|
|
$row->reservation_id = $reservationId;
|
|
$row->instance_id = $instanceId;
|
|
$row->operation_id = null;
|
|
$row->created_at = 900;
|
|
$row->updated_at = 900;
|
|
$row->save();
|
|
};
|
|
$insertIp('8.8.8.2', 'available');
|
|
$insertIp('8.8.8.3', 'reserved', 501);
|
|
$insertIp('8.8.8.4', 'assigned', null, 601);
|
|
$insertIp('8.8.8.5', 'disabled');
|
|
|
|
$now = 1000;
|
|
$history = [];
|
|
$successClient = $client([
|
|
new Response(200, [], $json($capacity($now))),
|
|
new Response(200, [], $json($network())),
|
|
], $history);
|
|
$success = (new CloudHostInventorySyncService(
|
|
$successClient, static function () use (&$now): int { return $now; }
|
|
))->sync(10);
|
|
|
|
$host->refresh();
|
|
$snapshot = CloudHostCapacitySnapshot::find(1);
|
|
$states = CloudPublicIp::orderBy('address')->pluck('state', 'address')->all();
|
|
$assert($success['checked'] === 1 && $success['succeeded'] === 1
|
|
&& $success['errors'] === [], 'A valid host observation did not succeed.');
|
|
$assert($host->health_state === 'healthy' && $host->last_seen_at === 1000
|
|
&& $host->health_checked_at === 1000 && $host->health_error_code === '',
|
|
'Successful host health markers are incorrect.');
|
|
$assert($snapshot !== null && $snapshot->sync_state === 'fresh'
|
|
&& $snapshot->cpu_total_cores === 16
|
|
&& $snapshot->storage_total_bytes === 1099511627776
|
|
&& $snapshot->public_ip_available_count === 3
|
|
&& $snapshot->observed_at === 1000,
|
|
'Capacity or public-IP counts were not persisted exactly.');
|
|
$assert($states === [
|
|
'8.8.8.2' => 'disabled',
|
|
'8.8.8.3' => 'reserved',
|
|
'8.8.8.4' => 'assigned',
|
|
'8.8.8.5' => 'available',
|
|
'8.8.8.6' => 'available',
|
|
], 'Free-list sync overwrote local occupancy or retained a missing free address.');
|
|
$assert(count($history) === 2
|
|
&& (string) $history[0]['request']->getUri()
|
|
=== 'http://127.0.0.1:8000/internal/v1/hosts/1/host/capacity'
|
|
&& (string) $history[1]['request']->getUri()
|
|
=== 'http://127.0.0.1:8000/internal/v1/hosts/1/host/network-options',
|
|
'Lifecycle inventory did not use both bounded host endpoints.');
|
|
$actorHeader = $history[0]['request']->getHeaderLine('X-Cloud-Actor');
|
|
$actorHeader .= str_repeat('=', (4 - strlen($actorHeader) % 4) % 4);
|
|
$actor = json_decode(base64_decode(strtr($actorHeader, '-_', '+/'), true), true);
|
|
$assert(($actor['user_id'] ?? null) === 99
|
|
&& ($actor['session_id'] ?? null) === 'cloud-host-inventory-sync'
|
|
&& ($actor['is_super_admin'] ?? null) === true,
|
|
'Shared daemon system actor was not used for inventory requests.');
|
|
|
|
$beforeCapacity = $snapshot->toArray();
|
|
$beforeStates = $states;
|
|
$now = 1010;
|
|
$notDue = (new CloudHostInventorySyncService(
|
|
$client([]), static function () use (&$now): int { return $now; }
|
|
))->sync(10);
|
|
$assert($notDue['checked'] === 0 && $notDue['errors'] === [],
|
|
'A host inside the configured due-time window was polled again.');
|
|
$invalidClient = $client([
|
|
new Response(200, [], $json($capacity($now, 32))),
|
|
new Response(200, [], $json($network(2))),
|
|
]);
|
|
$invalid = (new CloudHostInventorySyncService(
|
|
$invalidClient, static function () use (&$now): int { return $now; }
|
|
))->syncOne(1);
|
|
$host->refresh();
|
|
$snapshot->refresh();
|
|
$states = CloudPublicIp::orderBy('address')->pluck('state', 'address')->all();
|
|
$assert($invalid['degraded'] === 1
|
|
&& $invalid['errors'] === ['host_inventory_sync_failed']
|
|
&& $host->health_state === 'degraded'
|
|
&& $host->health_error_code === 'host_inventory_network_invalid'
|
|
&& $host->last_seen_at === 1000 && $host->health_checked_at === 1010,
|
|
'Invalid network response did not preserve last success and mark degraded.');
|
|
foreach (['cpu_total_cores', 'storage_total_bytes', 'observed_at'] as $field) {
|
|
$assert($snapshot->{$field} === $beforeCapacity[$field],
|
|
'Failure replaced last-known capacity field: ' . $field);
|
|
}
|
|
$assert($snapshot->sync_state === 'failed'
|
|
&& $snapshot->last_error_code === 'host_inventory_network_invalid'
|
|
&& $states === $beforeStates,
|
|
'Failure cleared capacity/IP data or exposed an unfixed diagnostic.');
|
|
|
|
$now = 1020;
|
|
$unavailableClient = $client([
|
|
new Response(503, [], '{"error":"private engine path must never persist"}'),
|
|
]);
|
|
$unavailable = (new CloudHostInventorySyncService(
|
|
$unavailableClient, static function () use (&$now): int { return $now; }
|
|
))->syncOne(1);
|
|
$host->refresh();
|
|
$snapshot->refresh();
|
|
$persisted = json_encode([
|
|
$host->health_error_code,
|
|
$snapshot->last_error_code,
|
|
], JSON_THROW_ON_ERROR);
|
|
$assert($unavailable['unavailable'] === 1
|
|
&& $host->health_state === 'unavailable'
|
|
&& $host->health_error_code === 'host_inventory_unavailable'
|
|
&& $host->last_seen_at === 1000 && $host->health_checked_at === 1020
|
|
&& !str_contains($persisted, 'private engine path'),
|
|
'Engine failure cleared last success or persisted an upstream error.');
|
|
|
|
echo "Cloud host capacity and public-IP lifecycle sync checks passed.\n";
|
|
}
|