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.
virt/web/app/Services/Cloud/CloudNetworkChangeOptionsSe...

405 lines
16 KiB
PHP

<?php
namespace App\Services\Cloud;
use App\Models\CloudHost;
use App\Models\CloudHostAgent;
use App\Models\CloudHostNetworkAttachment;
use App\Models\CloudInstance;
use App\Models\CloudPublicIp;
use App\Models\CloudPublicIpPool;
use App\Models\CloudResourcePool;
/** Read-only, dual-stack network-change capability projection. */
final class CloudNetworkChangeOptionsService
{
private const MAX_ATTACHMENTS = 64;
private const MAX_POOLS = 32;
private const MAX_IPV4_OPTIONS = self::MAX_POOLS * 254;
/** Tenant quote intentionally omits host, pool and address inventory. */
public static function tenantQuote(CloudInstance $instance): array
{
$context = self::context($instance);
$catalog = self::catalog($context);
$sourceId = $context['claim_set']->networkAttachmentId();
$source = $catalog['attachments'][$sourceId] ?? null;
$hasAutomaticIpv4 = is_array($source)
&& self::ipv4OptionCount($source) > 0;
$state = $catalog['malformed']
? 'invalid'
: ($hasAutomaticIpv4 ? 'ready' : 'not_configured');
$availability = self::availability($instance, $state, true);
return [
'instance_id' => (string) $instance->id,
'address_family' => 4,
'configuration_state' => $state,
'active_job' => $availability['active_job'],
'can_change' => $availability['can_change'],
'message' => $availability['message'],
];
}
/** Administrator inventory is explicit and never used as write authority. */
public static function adminOptions(CloudInstance $instance): array
{
$context = self::context($instance);
$catalog = self::catalog($context);
$currentAttachmentId =
$context['claim_set']->networkAttachmentId();
$attachments = array_values($catalog['attachments']);
$hasCandidate = false;
foreach ($attachments as $attachment) {
$hasIpv4 = self::ipv4OptionCount($attachment) > 0;
$hasIpv6 = ($attachment['ipv6']['pools'] ?? []) !== [];
if (($attachment['current'] && ($hasIpv4 || $hasIpv6))
|| (!$attachment['current'] && $hasIpv4 && $hasIpv6)) {
$hasCandidate = true;
break;
}
}
$state = $catalog['malformed']
? 'invalid' : ($hasCandidate ? 'ready' : 'not_configured');
$availability = self::availability($instance, $state);
return [
'instance_id' => (string) $instance->id,
'host_id' => (string) $context['host']->id,
'host_name' => (string) $context['host']->name,
'region' => (string) $context['host']->region,
'current_attachment_id' => (string) $currentAttachmentId,
'current_public_network' =>
$context['claim_set']->publicNetwork()->toArray(),
'attachments' => $attachments,
'configuration_state' => $state,
'active_job' => $availability['active_job'],
'can_change' => $availability['can_change'],
'message' => $availability['message'],
];
}
private static function context(CloudInstance $instance): array
{
try {
$spec = json_decode(
(string) $instance->spec_json,
true,
64,
JSON_THROW_ON_ERROR
);
$projected = CloudPublicNetworkSnapshot::fromArray(
is_array($spec) ? ($spec['public_network'] ?? null) : null
);
} catch (\Throwable) {
throw new CloudError(
'虚拟机双栈公网配置损坏,暂不能更换地址',
409
);
}
if (!is_array($spec) || array_is_list($spec)
|| ($spec['managed'] ?? false) !== true
|| ($spec['os_source'] ?? null) !== 'cloud_template'
|| (int) ($instance->host_id ?? 0) < 1
|| (int) ($instance->reservation_id ?? 0) < 1
|| (int) ($instance->resource_pool_id ?? 0) < 1) {
throw new CloudError(
'当前虚拟机不是支持网络配置的面板云镜像实例',
409
);
}
$claimSet = CloudPublicNetworkAllocationService::currentClaimSet(
(int) $instance->reservation_id,
'committed',
(int) $instance->id
);
if (!hash_equals(
$claimSet->publicNetwork()->fingerprint(),
$projected->fingerprint()
)) {
throw new CloudError('虚拟机双栈公网投影与地址账本不一致', 409);
}
$host = CloudHost::find((int) $instance->host_id);
$agent = CloudHostAgent::find((int) $instance->host_id);
$resourcePool = CloudResourcePool::find(
(int) $instance->resource_pool_id
);
if (!$host instanceof CloudHost || !(bool) $host->enabled
|| !$agent instanceof CloudHostAgent || !$agent->isReady()
|| !$resourcePool instanceof CloudResourcePool
|| (int) ($resourcePool->line_id ?? 0) < 1) {
throw new CloudError('宿主机公网网络变更能力不可用', 409);
}
return [
'instance' => $instance,
'host' => $host,
'agent' => $agent,
'resource_pool' => $resourcePool,
'claim_set' => $claimSet,
'line_id' => (int) $resourcePool->line_id,
];
}
private static function catalog(array $context): array
{
$instance = $context['instance'];
$agent = $context['agent'];
$testedSelectors = CloudAgentSettingsService::testedNetworkSelectors(
$agent
);
$attachmentRows = CloudHostNetworkAttachment::where(
'host_id',
(int) $instance->host_id
)->where('line_id', $context['line_id'])
->where('state', 'active')
->where('verification_state', 'verified')
->where('verified_agent_revision', (int) $agent->revision)
->where('last_verified_at', '>', 0)
->whereIn('network_selector', $testedSelectors)
->orderBy('priority')->orderBy('id')
->limit(self::MAX_ATTACHMENTS + 1)->get();
$malformed = $attachmentRows->count() > self::MAX_ATTACHMENTS;
$attachmentRows = $attachmentRows->take(self::MAX_ATTACHMENTS);
$attachments = [];
foreach ($attachmentRows as $attachment) {
if (!CloudPlacementNetworkService::attachmentReadyForAgent(
$attachment,
$agent
) || !CloudAgentSettingsService::publicNetworkReady(
$agent,
(string) $attachment->network_selector,
(int) $attachment->verified_agent_revision
)) {
continue;
}
$id = (int) $attachment->id;
$name = trim((string) ($attachment->name ?? ''));
$attachments[$id] = [
'attachment_id' => (string) $id,
'label' => $name !== '' ? $name
: (string) $attachment->network_selector,
'network_selector' =>
(string) $attachment->network_selector,
'current' => $id ===
$context['claim_set']->networkAttachmentId(),
'ipv4' => ['pools' => []],
'ipv6' => ['pools' => []],
];
}
if ($attachments === []) {
return ['attachments' => [], 'malformed' => $malformed];
}
$poolRows = CloudPublicIpPool::where(
'host_id',
(int) $instance->host_id
)->whereIn('network_attachment_id', array_keys($attachments))
->where('state', 'active')
->where('sync_state', 'applied')
->whereColumn(
'observed_revision',
'=',
'desired_revision'
)
->orderBy('network_attachment_id')->orderBy('address_family')
->orderBy('priority')->orderBy('id')
->limit(self::MAX_POOLS + 1)->get();
if ($poolRows->count() > self::MAX_POOLS) {
$malformed = true;
$poolRows = $poolRows->take(self::MAX_POOLS);
}
$pools = [];
$ipv4Ids = [];
$ipv6Ids = [];
foreach ($poolRows as $pool) {
$parsed = self::pool($pool, $context['host']);
if ($parsed === null
|| !isset($attachments[(int) $pool->network_attachment_id])) {
$malformed = true;
continue;
}
$dto = $parsed['dto'];
$pools[(int) $pool->id] = [
'row' => $pool,
'dto' => $dto,
'contract' => $parsed['contract'],
'excluded' => $dto['excluded_addresses'],
];
if ((int) $pool->address_family === 4) {
$ipv4Ids[] = (int) $pool->id;
} else {
$ipv6Ids[] = (int) $pool->id;
}
}
$ipv6Occupied = [];
if ($ipv6Ids !== []) {
$rows = CloudPublicIp::where('host_id', (int) $instance->host_id)
->whereIn('public_ip_pool_id', $ipv6Ids)
->whereIn('state', [
'reserved', 'assigned', 'changing', 'uncertain',
])->selectRaw(
'public_ip_pool_id, COUNT(*) AS aggregate'
)->groupBy('public_ip_pool_id')->get();
foreach ($rows as $row) {
$ipv6Occupied[(int) $row->public_ip_pool_id] =
(int) $row->aggregate;
}
}
$available = $ipv4Ids === [] ? collect()
: CloudPublicIp::where('host_id', (int) $instance->host_id)
->whereIn('public_ip_pool_id', $ipv4Ids)
->where('address_family', 4)
->where('state', 'available')
->whereNull('reservation_id')
->whereNull('reservation_ip_claim_id')
->whereNull('instance_id')->whereNull('operation_id')
->orderBy('id')->limit(self::MAX_IPV4_OPTIONS + 1)->get();
if ($available->count() > self::MAX_IPV4_OPTIONS) {
$malformed = true;
$available = $available->take(self::MAX_IPV4_OPTIONS);
}
$options = [];
foreach ($available as $ip) {
$poolId = (int) $ip->public_ip_pool_id;
$pool = $pools[$poolId] ?? null;
if (!is_array($pool)
|| !self::availableIpv4(
$ip,
$pool['row'],
$pool['contract'],
$pool['excluded']
)) {
$malformed = true;
continue;
}
$options[$poolId][] = [
'address_cidr' => (string) $ip->address . '/'
. (int) $ip->prefix_length,
];
}
foreach ($pools as $poolId => $pool) {
$row = $pool['row'];
$family = (int) $row->address_family;
if ($family === 6
&& ($ipv6Occupied[$poolId] ?? 0)
>= (int) $row->max_allocations) {
continue;
}
$attachmentId = (int) $row->network_attachment_id;
$dto = $pool['dto'];
if ($family === 4) {
$dto['available_options'] = $options[$poolId] ?? [];
}
$familyKey = $family === 6 ? 'ipv6' : 'ipv4';
$attachments[$attachmentId][$familyKey]['pools'][] = $dto;
}
return [
'attachments' => $attachments,
'malformed' => $malformed,
];
}
private static function pool(CloudPublicIpPool $pool,
CloudHost $host): ?array
{
try {
$contract = CloudPublicIpPoolContract::fromRow($pool);
$family = $contract->family();
$network = $contract->network();
$gateway = $contract->gateway();
$dns = $contract->dnsServers();
$reserved = $contract->reservedAddresses();
$allocationStart = $contract->allocationStart()?->text();
$allocationEnd = $contract->allocationEnd()?->text();
$excluded = [];
foreach (array_merge($reserved, $dns, [$gateway->text()])
as $raw) {
$address = CloudIpAddress::parse($raw);
if ($address->family() === $family) {
$excluded[$address->text()] = $address->text();
}
}
$management = CloudPanelUsageService::managementAddress($host);
if (is_string($management) && $management !== '') {
$managementAddress = CloudIpAddress::parse($management);
if ($managementAddress->family() === $family) {
$excluded[$managementAddress->text()] =
$managementAddress->text();
}
}
return ['contract' => $contract, 'dto' => [
'pool_key' => $contract->poolKey(),
'name' => trim((string) ($pool->name ?? '')),
'cidr' => $network->canonical(),
'guest_prefix' => $contract->guestPrefixLength(),
'gateway' => $gateway->text(),
'gateway_on_link' => $contract->gatewayOnLink(),
'dns_servers' => $dns,
'sparse' => $family === 6,
'allocation_start' => $allocationStart,
'allocation_end' => $allocationEnd,
'excluded_addresses' => array_values($excluded),
]];
} catch (\Throwable) {
return null;
}
}
private static function availableIpv4(CloudPublicIp $ip,
CloudPublicIpPool $pool, CloudPublicIpPoolContract $contract,
array $excluded): bool
{
try {
$address = CloudIpAddress::parse((string) $ip->address);
return (int) $ip->host_id === (int) $pool->host_id
&& (int) $ip->public_ip_pool_id === (int) $pool->id
&& $contract->family() === 4
&& (int) $ip->address_family === 4
&& (int) $ip->prefix_length
=== $contract->guestPrefixLength()
&& hash_equals($address->text(), (string) $ip->address)
&& is_string($ip->address_binary)
&& hash_equals($address->binary(), $ip->address_binary)
&& $contract->addressAllowed($address)
&& !in_array($address->text(), $excluded, true);
} catch (\Throwable) {
return false;
}
}
private static function ipv4OptionCount(array $attachment): int
{
$count = 0;
foreach ($attachment['ipv4']['pools'] ?? [] as $pool) {
$count += count($pool['available_options'] ?? []);
}
return $count;
}
private static function availability(CloudInstance $instance,
string $configurationState, bool $tenant = false): array
{
$decision = CloudPublicNetworkMutationAdmission::inspect($instance);
$canChange = $decision->allowed()
&& $configurationState === 'ready';
$message = match (true) {
$configurationState === 'invalid' => $tenant
? '面板公网 IPv4 地址池配置异常,请联系管理员。'
: '面板公网地址池配置异常,请先修复双栈地址账本。',
!$decision->allowed() => $decision->message,
$configurationState !== 'ready' => $tenant
? '当前公网 IPv4 地址池没有可用目标地址。'
: '当前公网地址池没有可用目标地址。',
default => '',
};
return [
'active_job' => $decision->activeJob,
'can_change' => $canChange,
'message' => $message,
];
}
}