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/Controllers/CloudApiController.php

1497 lines
66 KiB
PHP

<?php
namespace App\Controllers;
use App\Models\CloudInstance;
use App\Models\CloudInvoice;
use App\Models\CloudJob;
use App\Models\CloudOrder;
use App\Models\CloudServicePeriod;
use App\Models\CloudSSHKey;
use App\Models\User;
use App\Services\Auth;
use App\Services\AdminCsrf;
use App\Services\Config;
use App\Services\Cloud\CloudAccess;
use App\Services\Cloud\CloudDeploymentPageService;
use App\Services\Cloud\CloudEngineClient;
use App\Services\Cloud\CloudError;
use App\Services\Cloud\CloudFirewallService;
use App\Services\Cloud\CloudInput;
use App\Services\Cloud\CloudInstanceMetadata;
use App\Services\Cloud\CloudInstanceNameService;
use App\Services\Cloud\CloudInstancePageService;
use App\Services\Cloud\CloudInstanceRuntimeService;
use App\Services\Cloud\CloudJobService;
use App\Services\Cloud\CloudOperationCatalog;
use App\Services\Cloud\CloudOperationErrorCatalog;
use App\Services\Cloud\CloudInvoiceDetailPageService;
use App\Services\Cloud\CloudInvoicePageService;
use App\Services\Cloud\CloudInvoicePaymentService;
use App\Services\Cloud\CloudInvoiceService;
use App\Services\Cloud\CloudOrderService;
use App\Services\Cloud\CloudSecrets;
use App\Services\Cloud\CloudSSHKeys;
use App\Services\Cloud\CloudSnapshotService;
use App\Services\Cloud\CloudUserIsoFeature;
final class CloudApiController
{
private function actor($request): array
{
return $request->getAttribute('cloud_actor') ?? CloudAccess::actor();
}
private function billingActor($request): array
{
return $request->getAttribute('cloud_actor') ?? CloudAccess::actor(false);
}
private function user($request): User
{
$user = $request->getAttribute('auth_user');
return $user instanceof User ? $user : Auth::getUser();
}
private function json($response, array $value, int $status = 200)
{
return $response->withJson($value, $status)->withHeader('Cache-Control', 'no-store');
}
private function userIsoImportAllowed(array $actor, bool $throw = false): bool
{
$user = User::where('id', $actor['user_id'])->first();
$allowed = $user !== null && (int) $user->enable === 1
&& (int) $user->restrict_balance_purchase !== 1;
if (!$allowed && $throw) {
throw new CloudError('账户套餐购买及 ISO 上传服务已被管理员停用', 403);
}
return $allowed;
}
private function publicUserIsoRecord($value): ?array
{
if (!is_array($value) || preg_match('/^[0-9a-f]{32}$/D', (string) ($value['id'] ?? '')) !== 1) {
return null;
}
$name = is_string($value['name'] ?? null) ? trim($value['name']) : '';
if ($name === '' || preg_match('//u', $name) !== 1
|| preg_match('/[\x00-\x1F\x7F]/u', $name) === 1) {
return null;
}
return ['id' => strtolower((string) $value['id']),
'name' => mb_substr($name, 0, 128),
'size_bytes' => max(0, (int) ($value['size_bytes'] ?? 0)),
'sha256' => preg_match('/^[0-9a-f]{64}$/D', (string) ($value['sha256'] ?? '')) === 1
? (string) $value['sha256'] : '',
'created_at' => max(0, (int) ($value['created_at'] ?? 0))];
}
private function publicUserIsoRecords($values): array
{
$records = [];
foreach (is_array($values) ? $values : [] as $value) {
$record = $this->publicUserIsoRecord($value);
if ($record !== null) {
$records[] = $record;
}
}
return $records;
}
private function publicUserIsoJob($value): ?array
{
if (!is_array($value)
|| preg_match('/^[A-Za-z0-9_-]{8,80}$/D', (string) ($value['job_id'] ?? '')) !== 1) {
return null;
}
$status = CloudOperationErrorCatalog::userStatus($value['status'] ?? null);
if ($status === null) {
return null;
}
$job = ['job_id' => (string) $value['job_id'],
'status' => $status,
'phase' => CloudOperationErrorCatalog::userPhase(
$value['phase'] ?? null, $status, 'iso'
),
'created_at' => max(0, (int) ($value['created_at'] ?? 0))];
foreach (['started_at', 'finished_at'] as $key) {
if (isset($value[$key])) {
$job[$key] = max(0, (int) $value[$key]);
}
}
if (isset($value['iso'])) {
$record = $this->publicUserIsoRecord($value['iso']);
if ($record !== null) {
$job['iso'] = $record;
}
}
if (array_key_exists('error', $value)) {
$job['error'] = CloudEngineClient::safeUserIsoMessage($value['error'])
?? 'ISO 下载或导入失败,请联系管理员查看日志';
}
return $job;
}
/**
* Keep the user rescue-status endpoint a fixed DTO even if a future
* engine release adds diagnostics, volume names, or arbitrary messages.
*/
private function publicRescueStatus($value): array
{
if (!is_array($value)) {
return ['active' => false, 'staged' => false, 'power_state' => 'unknown',
'template_id' => null, 'template_name' => null, 'status' => null,
'job_id' => null, 'can_exit' => false];
}
$templateId = is_string($value['template_id'] ?? null)
&& preg_match('/^[0-9a-f]{32}$/D', $value['template_id']) === 1
? strtolower($value['template_id']) : null;
$jobId = is_string($value['job_id'] ?? null)
&& preg_match('/^[A-Za-z0-9_-]{8,80}$/D', $value['job_id']) === 1
? $value['job_id'] : null;
$status = $value['status'] ?? null;
$status = is_string($status) && in_array(strtolower(trim($status)),
['queued', 'running', 'staged', 'active', 'exiting', 'failed'], true)
? strtolower(trim($status)) : null;
$name = is_string($value['template_name'] ?? null)
? trim($value['template_name']) : '';
$name = $name !== '' && preg_match('//u', $name) === 1
&& preg_match('/[\x00-\x1F\x7F]/u', $name) !== 1
? mb_substr($name, 0, 128) : null;
return [
'active' => ($value['active'] ?? false) === true,
'staged' => ($value['staged'] ?? false) === true,
'power_state' => CloudInstanceMetadata::state($value['power_state'] ?? null),
'template_id' => $templateId,
'template_name' => $name,
'status' => $status,
'job_id' => $jobId,
'can_exit' => ($value['can_exit'] ?? false) === true,
];
}
/** Public rescue catalog fields; volume names and checksums stay private. */
private function publicRescueTemplates($value): array
{
$templates = [];
foreach (is_array($value) ? $value : [] as $item) {
if (!is_array($item)
|| !is_string($item['id'] ?? null)
|| preg_match('/^[0-9a-f]{32}$/D', $item['id']) !== 1
|| !is_string($item['name'] ?? null)) {
continue;
}
$name = trim($item['name']);
if ($name === '' || preg_match('//u', $name) !== 1
|| preg_match('/[\x00-\x1F\x7F]/u', $name) === 1) {
continue;
}
$templates[] = ['id' => strtolower($item['id']),
'name' => mb_substr($name, 0, 128)];
}
return $templates;
}
/** Keep the console capability response to the three browser fields. */
private function publicConsoleTicket($value): array
{
if (!is_array($value)
|| !is_string($value['ticket'] ?? null)
|| preg_match('/^[A-Za-z0-9_-]{32,256}$/D', $value['ticket']) !== 1
|| !is_string($value['websocket_path'] ?? null)
|| $value['websocket_path'] !== '/engine-console') {
throw new CloudError('控制台票据无效,请稍后重试', 502);
}
$expires = filter_var($value['expires_in'] ?? null, FILTER_VALIDATE_INT,
['options' => ['min_range' => 1, 'max_range' => 300]]);
if ($expires === false) {
throw new CloudError('控制台票据有效期无效,请稍后重试', 502);
}
return ['ticket' => $value['ticket'], 'expires_in' => (int) $expires,
'websocket_path' => '/engine-console'];
}
public function session($request, $response)
{
try {
$actor = CloudAccess::actor();
$user = $this->user($request);
return $this->json($response, ['authenticated' => true, 'username' => $user->user_name,
'user_id' => (int) $user->id, 'email' => $user->email,
'admin' => $actor['is_admin'], 'can_manage' => $actor['can_manage'],
'approved' => true, 'csrf_token' => AdminCsrf::token(), 'balance' => (string) $user->money]);
} catch (CloudError $error) {
return $this->json($response, ['authenticated' => false, 'detail' => $error->getMessage()], $error->httpStatus === 401 ? 200 : $error->httpStatus);
}
}
public function catalog($request, $response)
{
return $this->json($response, CloudDeploymentPageService::saleCatalog());
}
public function orders($request, $response)
{
$actor = $this->actor($request);
if ($request->getMethod() === 'POST') {
// Compatibility alias for a browser loaded before the unified
// billing release. It now creates only an unpaid invoice.
return $this->createProvisionInvoice($request, $response, $actor);
}
$query = CloudOrder::query();
if (!$actor['is_admin']) {
$query->where('user_id', $actor['user_id']);
}
return $this->json($response, ['orders' => $query->orderByDesc('id')->limit(200)->get()->map(
fn ($order) => CloudOrderService::display($order))->all()]);
}
public function order($request, $response, $args)
{
$actor = $this->actor($request);
$query = CloudOrder::where('id', $args['id']);
if (!$actor['is_admin']) {
$query->where('user_id', $actor['user_id']);
}
$order = $query->first();
if ($order === null) {
throw new CloudError('订单不存在', 404);
}
return $this->json($response, ['order' => CloudOrderService::display($order)]);
}
public function orderRequest($request, $response, $args)
{
$actor = $this->actor($request);
$key = (string) ($args['key'] ?? '');
if (preg_match('/^[A-Za-z0-9_.-]{16,128}$/D', $key) !== 1) {
throw new CloudError('订单请求标识无效');
}
// Deliberately owner-only even for administrators: this endpoint is
// used to reconcile a browser's possibly lost purchase response.
$order = CloudOrder::where('user_id', $actor['user_id'])
->where('idempotency_key', $key)->first();
if ($order === null) {
throw new CloudError('订单请求尚未建立', 404);
}
return $this->json($response, ['order' => CloudOrderService::display($order)]);
}
public function invoiceRequest($request, $response, $args)
{
$actor = $this->billingActor($request);
$key = (string) ($args['key'] ?? '');
if (preg_match('/^[A-Za-z0-9_.-]{16,128}$/D', $key) !== 1) {
throw new CloudError('账单请求标识无效');
}
$order = CloudOrder::where('user_id', $actor['user_id'])
->where('idempotency_key', $key)->first();
$invoice = $order === null ? null
: CloudInvoice::where('order_id', $order->id)->first();
if ($invoice === null || (string) ($invoice->purpose ?: 'renewal') !== 'provision') {
throw new CloudError('账单请求尚未建立', 404);
}
return $this->json($response,
['invoice' => CloudInvoiceService::display($invoice)]);
}
public function invoices($request, $response)
{
$actor = $this->billingActor($request);
if ($request->getMethod() === 'POST') {
return $this->createProvisionInvoice($request, $response, $actor);
}
$user = $this->user($request);
$query = $request->getQueryParams();
$pageValue = $query['page'] ?? '1';
if (is_array($pageValue)
|| preg_match('/^[1-9][0-9]{0,8}$/D', (string) $pageValue) !== 1) {
throw new CloudError('账单页码无效');
}
$perPage = 10;
$payload = CloudInvoicePageService::forUser(
(int) $actor['user_id'], (int) $pageValue, $perPage
);
$payload['balance'] = (string) $user->money;
return $this->json($response, $payload);
}
private function createProvisionInvoice($request, $response, array $actor)
{
$order = CloudOrderService::purchase(CloudInput::object($request), $actor);
$invoice = CloudInvoice::where('order_id', $order->id)->first();
if ($invoice === null) {
// An idempotency key from a pre-invoice deployment can still
// resolve to its historical order after an upgrade. Do not turn
// that expected compatibility case into an opaque HTTP 500.
if ((string) $order->status !== 'awaiting_payment') {
throw new CloudError('该请求已由旧版开通流程处理,请刷新实例列表或联系管理员核对', 409);
}
throw new \RuntimeException('开通账单创建失败');
}
return $this->json($response,
['invoice' => CloudInvoiceService::display($invoice)], 201);
}
public function invoice($request, $response, $args)
{
$actor = $this->billingActor($request);
$user = $this->user($request);
return $this->json($response, CloudInvoiceDetailPageService::forUser(
(int) $args['id'], (int) $actor['user_id'], $user,
(bool) $actor['is_admin']
));
}
public function invoiceStatus($request, $response, $args)
{
$actor = $this->billingActor($request);
return $this->json($response, [
'invoice' => CloudInvoiceDetailPageService::statusForUser(
(int) $args['id'], (int) $actor['user_id']
),
]);
}
public function payInvoice($request, $response, $args)
{
$actor = $this->billingActor($request);
$invoice = CloudInvoice::where('id', $args['id'])
->where('user_id', $actor['user_id'])->first();
if ($invoice === null) {
throw new CloudError('账单不存在', 404);
}
$body = CloudInput::object($request);
CloudInput::only($body, ['idempotency_key']);
$paid = CloudInvoiceService::payBalance($invoice, $actor,
trim((string) ($body['idempotency_key'] ?? '')));
$user = $this->user($request)->fresh();
return $this->json($response, ['invoice' => CloudInvoiceService::display($paid),
'balance' => (string) $user->money]);
}
public function createInvoicePayment($request, $response, $args)
{
$actor = $this->billingActor($request);
$invoice = CloudInvoice::where('id', $args['id'])
->where('user_id', $actor['user_id'])->first();
if ($invoice === null) {
throw new CloudError('账单不存在', 404);
}
$payment = CloudInvoicePaymentService::create($invoice, $this->user($request),
CloudInput::object($request),
(string) $request->getServerParam('REMOTE_ADDR', ''),
(string) $request->getHeaderLine('User-Agent'));
return $this->json($response, ['payment' => $payment], 201);
}
public function job($request, $response, $args)
{
$actor = $this->actor($request);
$query = CloudJob::where('id', $args['id']);
if (!$actor['is_admin']) {
$query->where('user_id', $actor['user_id']);
}
$job = $query->first();
if ($job === null) {
throw new CloudError('任务不存在', 404);
}
return $this->json($response, CloudJobService::display($job,
(bool) ($actor['is_admin'] ?? false)));
}
private function unavailableVm(CloudInstance $instance): array
{
return ['name' => $instance->name, 'state' => 'unknown',
'detail' => '宿主机暂时无法连接'];
}
/**
* Convert one private-engine VM row into the public live metadata DTO.
*
* Never merge the engine response directly into vmData: it contains
* storage source paths, console ports, rescue volume names and credential
* generation markers. CloudInstanceMetadata owns the static allowlist;
* this boundary adds only the explicitly public, UUID-checked power state
* and the validated discovery timestamp needed by the legacy detail view.
*/
private function publicVmMetadata(CloudInstance $instance, array $live): array
{
$snapshot = [
'id' => (string) $instance->id,
'api_id' => (string) $instance->id,
'uuid' => (string) $instance->uuid,
'name' => (string) $instance->name,
];
$view = CloudInstanceMetadata::publicView($snapshot, $live);
$snapshotUuid = strtolower(trim((string) $snapshot['uuid']));
$liveUuid = is_string($live['uuid'] ?? null)
? strtolower(trim($live['uuid'])) : '';
$matches = $snapshotUuid !== '' && $liveUuid !== ''
&& hash_equals($snapshotUuid, $liveUuid);
$view['state'] = $matches
? CloudInstanceMetadata::state($live['state'] ?? null) : 'unknown';
if ($matches && is_string($live['created_at'] ?? null)
&& preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/D',
$live['created_at']) === 1) {
// The engine emits UTC seconds. Keep the exact format instead of
// exposing arbitrary metadata or normalising an invalid date.
$view['created_at'] = $live['created_at'];
}
return $view;
}
/**
* Keep the durable business snapshot behind the same public boundary.
* CloudInput::safeResult() only removes credential-looking names; it is
* not an allowlist and therefore must never be returned as-is.
*/
private function publicVmSpec(array $spec): array
{
return CloudInstanceMetadata::publicSpec($spec);
}
/**
* Keep the metrics response bounded to the fields rendered by the user
* charts. Engine JSON is authenticated, but its schema is host-controlled
* and must not be forwarded as a future arbitrary-field channel.
*/
private function publicMetrics($value, string $uuid, string $range): array
{
$result = is_array($value) ? $value : [];
$interval = filter_var($result['interval_seconds'] ?? null,
FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 86400]]);
$points = [];
foreach (is_array($result['points'] ?? null) ? $result['points'] : [] as $point) {
if (!is_array($point) || array_is_list($point)) {
continue;
}
$timestamp = filter_var($point['timestamp'] ?? null,
FILTER_VALIDATE_INT, ['options' => ['min_range' => 0, 'max_range' => 4102444800]]);
if ($timestamp === false) {
continue;
}
$safe = ['timestamp' => (int) $timestamp];
foreach ([
'cpu_percent' => 100.0,
'memory_used_mib' => 1000000000.0,
'memory_total_mib' => 1000000000.0,
'disk_read_bps' => 1000000000000000.0,
'disk_write_bps' => 1000000000000000.0,
'network_rx_bps' => 1000000000000000.0,
'network_tx_bps' => 1000000000000000.0,
] as $key => $maximum) {
if (!array_key_exists($key, $point)) {
continue;
}
$metric = $point[$key];
if ($metric === null) {
$safe[$key] = null;
continue;
}
if (is_string($metric)) {
$metric = trim($metric);
if ($metric === '' || !is_numeric($metric)) {
continue;
}
}
if ((!is_int($metric) && !is_float($metric) && !is_string($metric))
|| is_bool($metric) || !is_finite((float) $metric)
|| (float) $metric < 0 || (float) $metric > $maximum) {
continue;
}
$safe[$key] = (float) $metric;
}
$points[] = $safe;
if (count($points) >= 600) {
break;
}
}
return ['vm_id' => $uuid, 'range' => $range,
'interval_seconds' => $interval === false ? 60 : (int) $interval,
'points' => $points];
}
/** Keep daily traffic to UTC day buckets and bounded byte counters. */
private function publicDailyTraffic($value, string $uuid, int $days): array
{
$result = is_array($value) ? $value : [];
$points = [];
foreach (is_array($result['points'] ?? null) ? $result['points'] : [] as $point) {
if (!is_array($point) || array_is_list($point)) {
continue;
}
$dayStart = filter_var($point['day_start'] ?? null,
FILTER_VALIDATE_INT, ['options' => ['min_range' => 0, 'max_range' => 4102444800]]);
if ($dayStart === false || ((int) $dayStart % 86400) !== 0) {
continue;
}
$safe = ['date' => gmdate('Y-m-d', (int) $dayStart),
'day_start' => (int) $dayStart];
foreach (['download_bytes', 'upload_bytes', 'total_bytes'] as $key) {
if (!array_key_exists($key, $point) || $point[$key] === null) {
$safe[$key] = null;
continue;
}
$bytes = $point[$key];
if (is_string($bytes) && preg_match('/^[0-9]+$/D', $bytes) !== 1) {
continue;
}
if (is_bool($bytes) || (!is_int($bytes) && !is_string($bytes))
|| (int) $bytes < 0 || (int) $bytes > 9000000000000000) {
continue;
}
$safe[$key] = (int) $bytes;
}
$points[] = $safe;
if (count($points) >= $days) {
break;
}
}
$from = filter_var($result['from'] ?? null, FILTER_VALIDATE_INT,
['options' => ['min_range' => 0, 'max_range' => 4102444800]]);
$until = filter_var($result['until'] ?? null, FILTER_VALIDATE_INT,
['options' => ['min_range' => 0, 'max_range' => 4102444800]]);
return ['vm_id' => $uuid, 'days' => $days, 'timezone' => 'UTC',
'from' => $from === false ? null : (int) $from,
'until' => $until === false ? null : (int) $until,
'points' => $points];
}
/**
* Resolve list-only VM dependencies in fixed-size database queries and
* targeted engine reads. The database collection is authoritative; a
* live row is requested only for the UUID already present in the
* actor-scoped instance collection, so this path never inventories a host.
*/
private function vmListContexts($instances, array $actor): array
{
if ($instances->isEmpty()) {
return [];
}
$instanceIds = $instances->pluck('id')->map(fn ($id) => (int) $id)->all();
$periodIds = $instances->pluck('current_period_id')->filter(
fn ($id) => $id !== null)->map(fn ($id) => (int) $id)->unique()->values()->all();
$periods = [];
if ($periodIds !== []) {
foreach (CloudServicePeriod::whereIn('id', $periodIds)
->whereIn('instance_id', $instanceIds)->get() as $period) {
$periods[(int) $period->id] = $period;
}
}
$futurePeriods = [];
foreach (CloudServicePeriod::whereIn('instance_id', $instanceIds)
->where('status', 'scheduled')
->selectRaw('instance_id, COUNT(*) AS period_count')
->groupBy('instance_id')->get() as $row) {
$futurePeriods[(int) $row->instance_id] = (int) $row->period_count;
}
$liveByInstance = [];
$engine = new CloudEngineClient();
foreach ($instances as $instance) {
$instanceId = (int) $instance->id;
$liveByInstance[$instanceId] = $this->unavailableVm($instance);
try {
$uuid = rawurlencode((string) $instance->uuid);
$live = $engine->host((int) $instance->host_id,
'GET', 'vms/' . $uuid, $actor);
if (is_array($live) && is_string($live['uuid'] ?? null)
&& hash_equals(strtolower((string) $instance->uuid),
strtolower(trim($live['uuid'])))) {
$liveByInstance[$instanceId] = $live;
}
} catch (CloudError $error) {
// Preserve a useful database-backed row when this host or
// targeted UUID is unavailable; other instances remain visible.
}
}
$contexts = [];
foreach ($instances as $instance) {
$period = $instance->current_period_id === null
? null : ($periods[(int) $instance->current_period_id] ?? null);
if ($period !== null && (int) $period->instance_id !== (int) $instance->id) {
$period = null;
}
$contexts[(int) $instance->id] = [
'vm' => $liveByInstance[(int) $instance->id] ?? $this->unavailableVm($instance),
'period' => $period,
'future_periods' => (int) ($futurePeriods[(int) $instance->id] ?? 0),
];
}
return $contexts;
}
private function vmData(CloudInstance $instance, array $actor, ?array $context = null): array
{
$owner = (int) $instance->user_id === (int) $actor['user_id'];
$global = ($actor['is_admin'] ?? false) && ($actor['is_super_admin'] ?? false)
&& ($actor['can_manage'] ?? false);
$decodedSpec = json_decode((string) $instance->spec_json, true);
$spec = is_array($decodedSpec) && !array_is_list($decodedSpec)
? $decodedSpec : [];
if ($context === null) {
try {
$vm = (new CloudEngineClient())->host((int) $instance->host_id, 'GET',
'vms/' . rawurlencode($instance->uuid), $actor);
} catch (CloudError $error) {
$vm = $this->unavailableVm($instance);
}
$period = $instance->current_period_id === null ? null
: CloudServicePeriod::where('id', $instance->current_period_id)
->where('instance_id', $instance->id)->first();
$futurePeriods = CloudServicePeriod::where('instance_id', $instance->id)
->where('status', 'scheduled')->count();
} else {
$vm = is_array($context['vm'] ?? null)
? $context['vm'] : $this->unavailableVm($instance);
$period = $context['period'] ?? null;
$futurePeriods = max(0, (int) ($context['future_periods'] ?? 0));
}
$publicVm = $this->publicVmMetadata($instance,
is_array($vm) ? $vm : []);
$createdAt = ($spec['record_source'] ?? '') === 'discovered'
? ($publicVm['created_at'] ?? null)
: gmdate('Y-m-d\TH:i:s\Z', (int) $instance->created_at);
$maximumFuturePeriods = max(1, min(120,
(int) Config::get('cloud_max_renewal_periods_ahead', 24)));
$lifecycleActive = (string) $instance->status === 'active';
$canDelete = $lifecycleActive && ($owner || $global);
// Traffic quota enforcement only disconnects guest NICs. It must not
// remove power, console or maintenance controls while the paid service
// period itself is still active.
$canOperate = $canDelete && $instance->serviceAvailable();
return array_merge(
$this->publicVmSpec($spec),
$publicVm,
['id' => (string) $instance->id, 'uuid' => $instance->uuid,
'name' => (string) $instance->name,
'user_id' => (int) $instance->user_id, 'owner_user_id' => (int) $instance->user_id,
'display_uuid' => $instance->uuid,
'created_at' => $createdAt,
'instance_status' => (string) $instance->status,
'service_status' => (string) $instance->service_status,
'network_status' => (string) $instance->network_status,
'service_expires_at' => $instance->expires_at === null ? null : (int) $instance->expires_at,
'current_period_started_at' => $period === null ? null : (int) $period->starts_at,
'current_period_ends_at' => $period === null ? null : (int) $period->ends_at,
'prepaid_periods' => $futurePeriods,
'traffic_download_bytes' => (int) $instance->traffic_download_bytes,
'traffic_upload_bytes' => (int) $instance->traffic_upload_bytes,
'traffic_used_bytes' => (int) $instance->traffic_download_bytes + (int) $instance->traffic_upload_bytes,
'traffic_quota_bytes' => (int) $instance->traffic_quota_bytes,
'renewal_price' => $instance->renewal_price === null ? null : (string) $instance->renewal_price,
'renewal_days' => (int) $instance->renewal_days,
'renewal_traffic_bytes' => (int) $instance->renewal_traffic_bytes,
'is_owner' => $owner,
'can_operate' => $canOperate,
'can_delete' => $canDelete,
'can_rename' => $canDelete,
'can_view_credential' => $owner || $global,
'can_renew' => $lifecycleActive && $owner
&& $instance->expires_at !== null && (int) $instance->renewal_days > 0
&& $instance->renewal_price !== null && $futurePeriods < $maximumFuturePeriods,
'has_initial_root_password' => ($owner || $global)
&& $instance->credential_cipher !== null]);
}
public function vms($request, $response)
{
$actor = $this->actor($request);
$query = CloudInstance::where('status', '<>', 'deleted');
if (!$actor['is_admin']) {
$query->where('user_id', $actor['user_id']);
}
$instances = $query->orderByDesc('id')->limit(200)->get();
$contexts = $this->vmListContexts($instances, $actor);
return $this->json($response, ['vms' => $instances->map(
fn ($instance) => $this->vmData($instance, $actor,
$contexts[(int) $instance->id] ?? []))->all()]);
}
/** Database-only paginated instance rows used after the SSR first page. */
public function vmPage($request, $response)
{
$actor = $this->billingActor($request);
$value = $request->getQueryParams()['page'] ?? '1';
if (is_array($value)
|| preg_match('/^[1-9][0-9]{0,8}$/D', (string) $value) !== 1) {
throw new CloudError('实例页码无效');
}
return $this->json($response, CloudInstancePageService::forActor(
$actor, (int) $value, 20
));
}
/**
* Load immutable libvirt metadata for only the actor-visible rows on the
* current page. This is intentionally separate from the frequent power
* state poll: XML and disk inspection happens once after SSR, then the
* sanitized result is cached in cloud_instances.spec_json.
*/
public function vmMetadata($request, $response)
{
$actor = $this->actor($request);
$raw = $request->getQueryParams()['ids'] ?? '';
if (is_array($raw) || preg_match('/^[1-9][0-9]*(?:,[1-9][0-9]*){0,19}$/D',
(string) $raw) !== 1) {
throw new CloudError('实例编号列表无效');
}
$ids = array_values(array_unique(array_map('intval', explode(',', (string) $raw))));
return $this->json($response, ['vms' => $this->vmMetadataRows($actor, $ids)]);
}
/** Load one detail page's static metadata without returning credentials. */
public function vmMetadataOne($request, $response, $args)
{
$actor = $this->actor($request);
$id = filter_var($args['id'] ?? null, FILTER_VALIDATE_INT,
['options' => ['min_range' => 1]]);
if ($id === false) {
throw new CloudError('实例编号无效');
}
$rows = $this->vmMetadataRows($actor, [(int) $id]);
if ($rows === []) {
// The actor-scoped database lookup deliberately does not disclose
// whether a foreign instance exists.
throw new CloudError('虚拟机不存在或无权访问', 404);
}
return $this->json($response, $rows[0]);
}
private function vmMetadataRows(array $actor, array $ids): array
{
$snapshots = CloudInstancePageService::forActorIds($actor, $ids);
$targets = $this->vmProbeTargets($actor, $ids);
$live = [];
$engine = new CloudEngineClient();
foreach ($this->vmSnapshotsByHost($snapshots, $targets) as $hostId => $group) {
$allowed = [];
$hostLive = [];
foreach ($group as $snapshot) {
$uuid = strtolower((string) $snapshot['uuid']);
$allowed[$uuid] = true;
}
try {
$payload = $engine->host((int) $hostId, 'GET', 'vm-metadata?ids=' .
rawurlencode(implode(',', array_keys($allowed))), $actor);
foreach (is_array($payload['items'] ?? null) ? $payload['items'] : [] as $item) {
if (!is_array($item) || !is_string($item['uuid'] ?? null)) {
continue;
}
$uuid = strtolower(trim($item['uuid']));
if (isset($allowed[$uuid])) {
$hostLive[$uuid] = $item;
$live[(int) $hostId . ':' . $uuid] = $item;
}
}
} catch (CloudError $error) {
// Static database fields stay usable when one host is offline;
// another host's metadata can still be returned and cached.
}
CloudInstanceMetadata::persistBatch($group, $hostLive);
}
$rows = [];
foreach ($snapshots as $snapshot) {
$uuid = strtolower((string) $snapshot['uuid']);
$target = $targets[(int) $snapshot['id']] ?? null;
$key = is_array($target) ? (int) $target['host_id'] . ':' . $uuid : '';
// Return the actor-visible identity even while its host is
// offline. The browser keeps the SSR fields and can distinguish
// temporary metadata unavailability from a missing instance.
$rows[] = CloudInstanceMetadata::publicView(
$snapshot, $live[$key] ?? []
);
}
return $rows;
}
/**
* Lightweight live state for the visible list page. Database ownership is
* resolved before any engine response is considered; each engine request
* contains only the already actor-scoped UUIDs and never lists a host.
*/
public function vmStatuses($request, $response)
{
$actor = $this->actor($request);
$raw = $request->getQueryParams()['ids'] ?? '';
if (is_array($raw) || preg_match('/^[1-9][0-9]*(?:,[1-9][0-9]*){0,99}$/D',
(string) $raw) !== 1) {
throw new CloudError('实例编号列表无效');
}
$ids = array_values(array_unique(array_map('intval', explode(',', (string) $raw))));
$snapshots = CloudInstancePageService::forActorIds($actor, $ids);
// Normal list refreshes are cache-only and therefore return without
// waiting on any host. An explicit live=1 request retains the
// previous synchronous engine probe for diagnostics/manual refresh.
$liveRequested = ($request->getQueryParams()['live'] ?? '') === '1';
if (!$liveRequested) {
$statuses = [];
foreach ($snapshots as $snapshot) {
$statuses[] = CloudInstancePageService::powerStatus($snapshot);
}
return $this->json($response, ['vms' => $statuses]);
}
$targets = $this->vmProbeTargets($actor, $ids);
$live = [];
$engine = new CloudEngineClient();
foreach ($this->vmSnapshotsByHost($snapshots, $targets) as $hostId => $group) {
$allowed = [];
foreach ($group as $snapshot) {
$allowed[strtolower((string) $snapshot['uuid'])] = true;
}
try {
$query = rawurlencode(implode(',', array_keys($allowed)));
$payload = $engine->host((int) $hostId, 'GET',
'vm-states?ids=' . $query, $actor);
foreach (is_array($payload['items'] ?? null) ? $payload['items'] : [] as $item) {
if (!is_array($item) || !is_string($item['uuid'] ?? null)) {
continue;
}
$uuid = strtolower(trim($item['uuid']));
if (isset($allowed[$uuid])) {
$live[(int) $hostId . ':' . $uuid] = $item;
}
}
} catch (CloudError $error) {
// The database rows remain visible with an unknown state; one
// offline host must not hide instances from another host.
}
}
$statuses = [];
foreach ($snapshots as $snapshot) {
$uuid = strtolower((string) $snapshot['uuid']);
$target = $targets[(int) $snapshot['id']] ?? null;
$key = is_array($target) ? (int) $target['host_id'] . ':' . $uuid : '';
$statuses[] = CloudInstancePageService::powerStatus(
$snapshot, $live[$key] ?? []
);
}
return $this->json($response, ['vms' => $statuses]);
}
/** Cache-first state for one owner-scoped detail page. */
public function vmStatus($request, $response, $args)
{
$actor = $this->actor($request);
$snapshot = CloudInstancePageService::statusForActor($actor, $args['id']);
$live = [];
// Detail pages use the runtime cache by default, so opening a VM does
// not wait for a potentially slow/offline host. Explicit live=1
// refreshes use a short deadline and write a valid observation through.
if (($request->getQueryParams()['live'] ?? '') === '1') {
try {
$instance = CloudAccess::instance($args['id'], $actor);
if (!hash_equals(strtolower((string) $snapshot['uuid']),
strtolower((string) $instance->uuid))) {
throw new CloudError('虚拟机状态已变更,请刷新后重试', 409);
}
$runtimeRevision = null;
try {
// Seed and claim against a locked current instance row.
// The potentially slow host request stays outside that
// short transaction; a later worker write or delete then
// invalidates this revision.
$runtimeRevision = CloudInstanceRuntimeService::beginCurrentObservation(
(int) $instance->id,
(int) $instance->host_id,
(string) $instance->uuid
);
} catch (\Throwable $error) {
// Live state remains useful during a rolling schema
// update, but an unclaimed response must not write back.
}
$candidate = (new CloudEngineClient(null, 5.0))->host(
(int) $instance->host_id,
'GET',
'vms/' . rawurlencode((string) $snapshot['uuid']) . '/state',
$actor
);
$observedState = is_array($candidate)
? CloudInstanceRuntimeService::normalizeState(
$candidate['state'] ?? ($candidate['power_state'] ?? null)
) : 'unknown';
if (is_array($candidate)
&& is_string($candidate['uuid'] ?? null)
&& hash_equals(strtolower((string) $snapshot['uuid']),
strtolower(trim($candidate['uuid'])))
&& $observedState !== 'unknown') {
$candidate['state'] = $observedState;
try {
// The same database identity used for authorisation is
// also the cache-write key. Only the revision claimed
// before the host request may publish this response.
if ($runtimeRevision !== null) {
CloudInstanceRuntimeService::markObserved(
(int) $instance->id,
(int) $instance->host_id,
(string) $instance->uuid,
$observedState,
null,
$runtimeRevision
);
}
} catch (\Throwable $error) {
// Runtime persistence is a write-through optimisation;
// a live observation remains useful during a rolling
// schema update, while the previous cache stays intact.
error_log('cloud live runtime write unavailable: '
. get_class($error));
}
$live = $candidate;
}
} catch (CloudError $error) {
// Preserve the identity-checked runtime snapshot when the
// optional live probe cannot reach the host.
}
}
return $this->json($response,
CloudInstancePageService::status($snapshot, $live));
}
public function vm($request, $response, $args)
{
$actor = $this->actor($request);
return $this->json($response, $this->vmData(CloudAccess::instance($args['id'], $actor), $actor));
}
/** Rename only the PHP-owned display label; no engine operation is sent. */
public function displayName($request, $response, $args)
{
$body = CloudInput::object($request);
CloudInput::only($body, ['name']);
return $this->json($response, CloudInstanceNameService::rename(
$args['id'] ?? null,
$this->actor($request),
$body['name'] ?? null
));
}
public function operationLogs($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor);
$rawPage = $request->getQueryParams()['page'] ?? '1';
$page = is_string($rawPage) || is_int($rawPage)
? filter_var((string) $rawPage, FILTER_VALIDATE_INT,
['options' => ['min_range' => 1, 'max_range' => 1000000]])
: false;
if ($page === false) {
throw new CloudError('操作日志页码无效', 400);
}
return $this->json($response, array_merge(
CloudJobService::operationLogs($instance, (int) $page, 10),
['instance_id' => (string) $instance->id]
));
}
/** Database-only read and revisioned whole-policy firewall replacement. */
public function firewall($request, $response, $args)
{
$actor = $this->actor($request);
$write = $request->getMethod() === 'PUT';
$instance = CloudAccess::instance($args['id'], $actor, $write);
if (!$write) {
return $this->json($response,
CloudFirewallService::listing($instance, $actor));
}
$queued = CloudFirewallService::apply(
$instance, $actor, CloudInput::object($request)
);
$job = $queued['job'] ?? null;
if ($job === null) {
return $this->json($response, array_merge($queued['policy'], [
'unchanged' => true,
]));
}
return $this->json($response, array_merge($queued['policy'], [
'unchanged' => false,
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
]), 202);
}
/** Database-only catalog read; create is queued through the durable worker. */
public function snapshots($request, $response, $args)
{
$actor = $this->actor($request);
$write = $request->getMethod() === 'POST';
$instance = CloudAccess::instance($args['id'], $actor, $write);
if (!$write) {
return $this->json($response,
CloudSnapshotService::listing($instance, $actor));
}
$created = CloudSnapshotService::create(
$instance, $actor, CloudInput::object($request)
);
$job = $created['job'];
return $this->json($response, [
'snapshot' => $created['snapshot'],
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
], 202);
}
public function restoreSnapshot($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$queued = CloudSnapshotService::restore($instance, $actor,
(string) $args['snapshot_key'], CloudInput::object($request));
$job = $queued['job'];
return $this->json($response, [
'snapshot' => $queued['snapshot'],
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
], 202);
}
public function deleteSnapshot($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$queued = CloudSnapshotService::delete($instance, $actor,
(string) $args['snapshot_key'], CloudInput::object($request));
$job = $queued['job'];
return $this->json($response, [
'snapshot' => $queued['snapshot'],
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
], 202);
}
/**
* Server-only placement targets for an already bounded list of actor-visible
* instances. These rows are never serialized into a user response.
*/
private function vmProbeTargets(array $actor, array $ids): array
{
$ids = array_values(array_unique(array_filter(array_map(
static fn ($id): int => max(0, (int) $id), $ids
))));
if ($ids === []) {
return [];
}
$query = CloudInstance::where('status', '<>', 'deleted')->whereIn('id', $ids);
if (!($actor['is_admin'] ?? false)) {
$query->where('user_id', (int) $actor['user_id']);
}
$targets = [];
foreach ($query->get(['id', 'uuid', 'host_id']) as $instance) {
$targets[(int) $instance->id] = [
'uuid' => strtolower((string) $instance->uuid),
'host_id' => (int) $instance->host_id,
];
}
return $targets;
}
private function vmSnapshotsByHost(array $snapshots, array $targets): array
{
$groups = [];
foreach ($snapshots as $snapshot) {
$target = $targets[(int) ($snapshot['id'] ?? 0)] ?? null;
$uuid = strtolower((string) ($snapshot['uuid'] ?? ''));
$hostId = is_array($target) ? max(0, (int) ($target['host_id'] ?? 0)) : 0;
if ($hostId > 0 && $uuid !== ''
&& hash_equals((string) ($target['uuid'] ?? ''), $uuid)) {
$groups[$hostId][] = $snapshot;
}
}
return $groups;
}
public function metrics($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor);
$query = $request->getQueryParams();
$range = $query['range'] ?? '1h';
if (!in_array($range, ['1h', '24h', '7d', '30d'], true)) {
throw new CloudError('指标时间范围无效');
}
$suffix = '?range=' . rawurlencode($range);
$value = (new CloudEngineClient())->host((int) $instance->host_id, 'GET',
'vms/' . rawurlencode($instance->uuid) . '/metrics' . $suffix, $actor);
return $this->json($response, $this->publicMetrics($value,
strtolower((string) $instance->uuid), $range));
}
public function dailyTraffic($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor);
$rawDays = $request->getQueryParams()['days'] ?? '30';
if (!is_string($rawDays) && !is_int($rawDays)) {
throw new CloudError('流量统计天数无效');
}
$days = filter_var((string) $rawDays, FILTER_VALIDATE_INT,
['options' => ['min_range' => 1, 'max_range' => 30]]);
if ($days === false) {
throw new CloudError('流量统计天数必须为 1 至 30');
}
$value = (new CloudEngineClient())->host((int) $instance->host_id,
'GET', 'vms/' . rawurlencode($instance->uuid) . '/traffic/daily?days=' . (int) $days,
$actor);
return $this->json($response, $this->publicDailyTraffic($value,
strtolower((string) $instance->uuid), (int) $days));
}
public function credential($request, $response, $args)
{
$instance = CloudAccess::instance($args['id'], $this->actor($request), true);
if ($instance->credential_cipher === null) {
throw new CloudError('该虚拟机没有面板保存的初始密码', 404);
}
return $this->json($response, CloudSecrets::decrypt($instance->credential_cipher));
}
public function consoleTicket($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$this->requireService($instance, $actor);
$actor = CloudAccess::vmActor($instance, $actor);
$value = (new CloudEngineClient())->host((int) $instance->host_id, 'POST',
'vms/' . rawurlencode($instance->uuid) . '/console-ticket', $actor, []);
return $this->json($response, $this->publicConsoleTicket($value));
}
public function actions($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$actor = CloudAccess::vmActor($instance, $actor);
$body = CloudInput::object($request);
CloudInput::only($body, ['action']);
$action = $body['action'] ?? null;
if (!is_string($action) || !CloudOperationCatalog::isPowerAction($action)) {
throw new CloudError('操作无效');
}
if (in_array($action, ['start', 'reboot', 'reset'], true)) {
$this->requireService($instance, $actor);
}
$job = CloudJobService::enqueue($instance, $actor, 'action', 'POST', '/actions', $body);
// The validated request already contains the non-sensitive action;
// use it directly instead of decrypting the freshly queued payload a
// second time merely to build the acknowledgement.
$labels = CloudOperationCatalog::labels((string) $job->kind, $action);
return $this->json($response, [
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
'kind' => (string) $job->kind,
'action' => $action,
'kind_label' => $labels['kind_label'],
'action_label' => $labels['action_label'],
], 202);
}
public function reinstall($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$this->requireService($instance, $actor);
$body = CloudInput::object($request);
CloudInput::only($body, ['template_id', 'ssh_key_id', 'root_password', 'confirmation_name']);
if (($body['confirmation_name'] ?? '') !== $instance->name) {
throw new CloudError('请填写虚拟机名称确认重装');
}
$body['template_id'] = CloudInput::template($body['template_id'] ?? null);
$key = CloudSSHKeys::owned($body['ssh_key_id'] ?? null, $actor['user_id']);
unset($body['ssh_key_id']);
$body['ssh_public_key'] = $key?->public_key ?? '';
$requestedPassword = $body['root_password'] ?? null;
$passwordGenerated = $requestedPassword === null || $requestedPassword === '';
$body['root_password'] = CloudInput::password($requestedPassword);
$job = CloudJobService::enqueue($instance, $actor, 'reinstall', 'POST', '/reinstall', $body,
['password' => $body['root_password'], 'login_name' => 'root', 'auth_mode' => $key ? 'password_and_key' : 'password']);
// The password is generated before the asynchronous job is queued. It
// is returned only in this no-store response so the browser can show a
// one-time receipt immediately; job/status endpoints continue to strip
// credentials and the durable copy remains encrypted on the instance.
return $this->json($response, [
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
'initial_password' => $passwordGenerated ? $body['root_password'] : null,
'password_generated' => $passwordGenerated,
], 202);
}
/**
* Queue one owner-scoped instance setting at a time. Passwords are
* generated server-side and returned only in this no-store acknowledgement;
* the asynchronous job and status DTO never contain plaintext credentials.
*/
public function settings($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$this->requireService($instance, $actor);
$body = CloudInput::object($request);
CloudInput::only($body, ['hostname', 'ssh_key_id', 'reset_password', 'confirm_restart']);
if (($body['confirm_restart'] ?? false) !== true) {
throw new CloudError('修改实例设置前必须确认虚拟机会短暂重启');
}
$hasHostname = array_key_exists('hostname', $body);
$hasPassword = array_key_exists('reset_password', $body);
$hasKey = array_key_exists('ssh_key_id', $body);
if ((int) $hasHostname + (int) $hasPassword + (int) $hasKey !== 1) {
throw new CloudError('每次只能提交一项实例设置');
}
$setting = '';
$jobBody = ['confirm_restart' => true];
$credential = null;
$initialPassword = null;
if ($hasHostname) {
$jobBody['hostname'] = CloudInput::hostname($body['hostname']);
$setting = 'hostname';
} elseif ($hasPassword) {
if ($body['reset_password'] !== true) {
throw new CloudError('请确认生成新密码并重启实例');
}
$initialPassword = CloudInput::password(null);
$jobBody['root_password'] = $initialPassword;
$credential = [
'password' => $initialPassword,
'login_name' => 'root',
'auth_mode' => 'password',
];
$setting = 'password';
} else {
// The browser submits only an identifier. Resolve it against the
// instance owner so a privileged viewer cannot attach another
// account's key to this guest.
$key = CloudSSHKeys::owned($body['ssh_key_id'] ?? null, (int) $instance->user_id);
if ($key === null) {
throw new CloudError('请选择要使用的 SSH 公钥');
}
$jobBody['ssh_public_key'] = $key->public_key;
$setting = 'ssh_key';
}
$job = CloudJobService::enqueue($instance, $actor, 'instance_settings', 'POST',
'/settings', $jobBody, $credential);
return $this->json($response, [
'job_id' => (string) $job->id,
'status_url' => '/api/v1/jobs/' . $job->id,
'setting' => $setting,
'initial_password' => $initialPassword,
'password_generated' => $initialPassword !== null,
], 202);
}
public function rescue($request, $response, $args)
{
$actor = $this->actor($request);
$write = $request->getMethod() !== 'GET';
$instance = CloudAccess::instance($args['id'], $actor, $write);
$suffix = '/rescue' . ($args['rescue_action'] ?? '');
if (!$write) {
$status = (new CloudEngineClient())->host((int) $instance->host_id, 'GET',
'vms/' . rawurlencode($instance->uuid) . $suffix, $actor);
return $this->json($response, $this->publicRescueStatus($status));
}
$this->requireService($instance, $actor);
$body = CloudInput::object($request);
CloudInput::only($body, ['template_id', 'confirmation_name', 'ack_data_loss']);
if (($body['confirmation_name'] ?? '') !== $instance->name) {
throw new CloudError('请填写虚拟机名称确认操作');
}
if ($suffix === '/rescue/exit') {
// The saved original XML may predate a traffic-quota block. Pass
// the current billing target so the engine restores every NIC in
// the correct link state before it starts the normal system.
$body['network_suspended'] = in_array(
(string) $instance->network_status,
['blocking', 'blocked_traffic', 'blocked_expired', 'block_failed'], true);
}
$job = CloudJobService::enqueue($instance, $actor, 'rescue', 'POST', $suffix, $body);
return $this->json($response, ['job_id' => (string) $job->id, 'status_url' => '/api/v1/jobs/' . $job->id], 202);
}
private function requireService(CloudInstance $instance, array $actor): void
{
$global = ($actor['is_super_admin'] ?? false) && ($actor['can_manage'] ?? false);
if (!$global && !$instance->serviceAvailable()) {
throw new CloudError('实例服务已到期或正在恢复,请先续费并等待恢复完成', 409);
}
}
public function delete($request, $response, $args)
{
$actor = $this->actor($request);
$instance = CloudAccess::instance($args['id'], $actor, true);
$body = CloudInput::object($request);
CloudInput::only($body, ['confirmation_name', 'delete_disks']);
if (($body['confirmation_name'] ?? '') !== $instance->name) {
throw new CloudError('请填写虚拟机名称确认删除');
}
$deleteDisks = filter_var($body['delete_disks'] ?? true,
FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
if ($deleteDisks === null
|| ((string) $instance->service_status !== 'exempt' && !$deleteDisks)) {
throw new CloudError('销售实例删除必须同步删除面板管理的虚拟磁盘');
}
$job = CloudJobService::enqueue($instance, $actor, 'delete', 'DELETE',
'?delete_disks=' . ($deleteDisks ? 'true' : 'false'), []);
return $this->json($response, ['job_id' => (string) $job->id, 'status_url' => '/api/v1/jobs/' . $job->id], 202);
}
public function sshKeys($request, $response)
{
$actor = $this->actor($request);
if ($request->getMethod() === 'POST') {
$body = CloudInput::object($request);
CloudInput::only($body, ['name', 'public_key']);
$name = $body['name'] ?? '';
if (!is_string($name) || trim($name) === '' || mb_strlen($name) > 80) {
throw new CloudError('公钥名称需为 1 至 80 字符');
}
$parsed = CloudSSHKeys::parse($body['public_key'] ?? '');
if (CloudSSHKey::where('user_id', $actor['user_id'])->where('fingerprint', $parsed['fingerprint'])->exists()) {
throw new CloudError('该公钥已经添加', 409);
}
$key = new CloudSSHKey();
$key->user_id = $actor['user_id'];
$key->name = trim($name);
$key->public_key = $parsed['public_key'];
$key->fingerprint = $parsed['fingerprint'];
$key->created_at = time();
$key->save();
return $this->json($response, ['id' => (int) $key->id, 'name' => $key->name, 'fingerprint' => $key->fingerprint], 201);
}
return $this->json($response, [
'keys' => CloudDeploymentPageService::sshKeys((int) $actor['user_id']),
]);
}
public function deleteKey($request, $response, $args)
{
$key = CloudSSHKeys::owned($args['id'], $this->actor($request)['user_id']);
$key->delete();
return $this->json($response, ['deleted' => true]);
}
public function resources($request, $response)
{
$actor = $this->actor($request);
$query = $request->getQueryParams();
// Cloud images are a panel-wide catalog. Host-specific replication is
// owned by the private engine and must not make the browser reload or
// replace the catalog whenever a customer changes region, line or offer.
$catalog = CloudDeploymentPageService::freshTemplateCatalog($actor);
$templatePayload = [
'templates' => is_array($catalog['templates'] ?? null)
? $catalog['templates'] : [],
];
// Replication state is a host-internal catalog detail. It can contain
// pool names, source paths, or future engine fields and is not needed
// by the user image picker, so never copy it into a public response.
if (!isset($query['vm_id'])) {
return $this->json($response, $templatePayload);
}
$hostId = (int) CloudAccess::instance($query['vm_id'], $actor)->host_id;
$engine = new CloudEngineClient();
$rescue = $engine->host($hostId, 'GET', 'rescue-templates', $actor);
// The rescue response can contain host paths or future internal fields.
// The browser only needs display names, so construct a fixed DTO instead
// of unsetting a few currently-known fields and exposing future ones.
$public = $templatePayload;
$public['rescue_templates'] = $this->publicRescueTemplates(
$rescue['templates'] ?? []
);
return $this->json($response, $public);
}
private function userIsoWriteActor(array $actor): array
{
// Engine mutations require an explicit write grant. The engine still
// derives the storage directory and catalog owner from this user_id;
// this flag does not grant access to another account's ISO records.
$actor['can_manage'] = true;
return $actor;
}
public function userIsos($request, $response)
{
$actor = $this->actor($request);
CloudUserIsoFeature::assertEnabled();
$engine = new CloudEngineClient();
if ($request->getMethod() === 'POST') {
$this->userIsoImportAllowed($actor, true);
$body = CloudInput::object($request);
CloudInput::only($body, ['name', 'url']);
$result = $engine->request('POST', '/internal/v1/user-isos/import',
$this->userIsoWriteActor($actor), $body);
$jobId = (string) ($result['job_id'] ?? '');
if (preg_match('/^[A-Za-z0-9_-]{8,80}$/D', $jobId) !== 1) {
throw new CloudError('虚拟化引擎未返回有效的 ISO 下载任务', 502);
}
return $this->json($response, ['job_id' => $jobId, 'status' => 'queued',
'status_url' => '/api/v1/user-isos/import-jobs/'
. rawurlencode($jobId)], 202);
}
$result = $engine->request('GET', '/internal/v1/user-isos', $actor);
$public = ['isos' => $this->publicUserIsoRecords($result['isos'] ?? []),
'can_import' => $this->userIsoImportAllowed($actor)];
if (isset($result['active_import_job'])) {
$active = $this->publicUserIsoJob($result['active_import_job']);
if ($active !== null && in_array($active['status'], ['queued', 'running'], true)) {
$public['active_import_job'] = $active;
}
}
return $this->json($response, $public);
}
public function userIsoJob($request, $response, $args)
{
$actor = $this->actor($request);
CloudUserIsoFeature::assertEnabled();
$jobId = (string) ($args['job_id'] ?? '');
if (preg_match('/^[A-Za-z0-9_-]{8,80}$/D', $jobId) !== 1) {
throw new CloudError('ISO 下载任务编号无效');
}
$job = $this->publicUserIsoJob((new CloudEngineClient())->request(
'GET', '/internal/v1/user-isos/import-jobs/' . rawurlencode($jobId), $actor));
if ($job === null) {
throw new CloudError('虚拟化引擎返回了无效的 ISO 下载任务', 502);
}
return $this->json($response, $job);
}
public function deleteUserIso($request, $response, $args)
{
$actor = $this->actor($request);
CloudUserIsoFeature::assertEnabled();
$isoId = (string) ($args['id'] ?? '');
if (preg_match('/^[0-9a-f]{32}$/D', $isoId) !== 1) {
throw new CloudError('ISO 镜像标识无效');
}
$deleted = (new User())->getConnection()->transaction(function () use ($actor, $isoId) {
$user = User::where('id', $actor['user_id'])->lockForUpdate()->first();
if ($user === null || (int) $user->enable !== 1) {
throw new CloudError('账户不可用', 403);
}
foreach (CloudOrder::where('user_id', $actor['user_id'])
->whereIn('status', ['awaiting_payment', 'queued', 'running', 'uncertain'])
->get(['spec_json']) as $order) {
$spec = json_decode((string) $order->spec_json, true);
if (is_array($spec) && isset($spec['user_iso_id'])
&& is_string($spec['user_iso_id'])
&& hash_equals($isoId, $spec['user_iso_id'])) {
throw new CloudError('该 ISO 正被未完成的开通账单或创建任务使用,暂不能删除', 409);
}
}
(new CloudEngineClient())->request('DELETE',
'/internal/v1/user-isos/' . $isoId, $this->userIsoWriteActor($actor));
return ['deleted' => true];
}, 3);
return $this->json($response, $deleted);
}
}