*/ private const DATABASE_MODELS = [ 'StandalonePostgresql' => StandalonePostgresql::class, 'StandaloneMysql' => StandaloneMysql::class, 'StandaloneMariadb' => StandaloneMariadb::class, 'StandaloneMongodb' => StandaloneMongodb::class, 'StandaloneRedis' => StandaloneRedis::class, 'StandaloneKeydb' => StandaloneKeydb::class, 'StandaloneDragonfly' => StandaloneDragonfly::class, 'StandaloneClickhouse' => StandaloneClickhouse::class, 'StandaloneSqlite' => StandaloneSqlite::class, ]; /** @var array */ private array $privateKeyMap = []; /** @var array */ private array $githubAppMap = []; /** @var array */ private array $gitlabAppMap = []; /** @var array */ private array $giteaAppMap = []; /** @var array */ private array $s3StorageMap = []; /** @var array */ private array $cloudTokenMap = []; /** @var array */ private array $integrationTokenMap = []; /** @var array */ private array $dnsZoneMap = []; /** * Imported owned DNS records that carry the ownership comment of the source instance. This instance takes * ownership at the provider after the import transaction commits. * * @var list */ private array $pendingDnsAdoptions = []; /** * Icons of imported projects. They are stored after the import transaction commits, so a storage error * cannot roll back DB rows. * * @var list}> */ private array $pendingProjectIcons = []; /** @var array */ private array $volumeMap = []; /** @var array */ private array $applicationMap = []; /** @var array */ private array $previewMap = []; /** @var array */ private array $serviceMap = []; /** @var array */ private array $serviceApplicationMap = []; /** @var array */ private array $databaseMap = []; /** * Imported volumes that mount a SQLite database volume, keyed by volume id. The database may be imported later. * * @var array */ private array $pendingSqliteLinks = []; /** * Warnings about references of imported resources that this instance cannot resolve. * * @var list */ private array $importWarnings = []; /** * Applications whose git source needs a check after the transfer: a system-wide source of the source * instance, or a source that this instance does not have. * * @var list */ private array $gitSourceApplications = []; /** * @param array $bundle * @return array{ * dry_run: bool, * warnings: list, * server_uuid: string|null, * private_key_uuid: string|null, * created: array, * preserved_uuids: bool, * export_id: string|null, * claimed: bool, * claim: array|null, * checklist: list * } */ public function import( array $bundle, int $teamId, bool $dryRun = false, bool $preserveUuids = true, bool $adoptMode = true, ): array { // Checks every id, list size, and imported value before anything is written. $validation = ServerTransferBundle::validate($bundle); if (! $validation['valid']) { throw ValidationException::withMessages(['bundle' => $validation['errors']]); } $this->assertValidServerPayload((array) data_get($bundle, 'server', [])); if ($adoptMode && ! $preserveUuids) { throw ValidationException::withMessages([ 'preserve_uuids' => ['Adopt mode keeps the running containers, so it needs the original UUIDs. Import with preserve_uuids=true.'], ]); } $warnings = $validation['warnings']; if (is_array(data_get($bundle, 'warnings'))) { $warnings = array_values(array_unique(array_merge($warnings, $bundle['warnings']))); } $serverUuid = (string) data_get($bundle, 'server.uuid'); $serverIp = (string) data_get($bundle, 'server.ip'); // A server that comes back replaces the archived copy that this instance kept from the first transfer. $archive = $preserveUuids ? $this->replaceableArchive($serverUuid, $teamId) : null; $uuidConflict = $archive === null && $preserveUuids && Server::withTrashed()->where('uuid', $serverUuid)->exists(); $ipConflict = Server::where('ip', Server::normalizeIp($serverIp))->when($archive, fn ($query) => $query->whereKeyNot($archive->id))->exists(); if (! $dryRun) { $this->assertCanImport($serverUuid, $serverIp, $teamId, $preserveUuids); // The import validates the server over SSH, so it uses the same Cloud limit as a new server. Server::throttleValidation($teamId, $serverIp); } if ($uuidConflict) { $warnings[] = "A server with UUID {$serverUuid} already exists on this instance."; } if ($ipConflict) { $warnings[] = "A server with IP/domain {$serverIp} already exists on this instance."; } $created = [ 'projects' => 0, 'environments' => 0, 'applications' => 0, 'databases' => 0, 'services' => 0, 'destinations' => 0, 'private_keys' => 0, 'github_apps' => 0, 'gitlab_apps' => 0, 'gitea_apps' => 0, 's3_storages' => 0, 'cloud_provider_tokens' => 0, 'integration_tokens' => 0, 'managed_dns_records' => 0, 'ssl_certificates' => 0, 'volume_backups' => 0, 'previews' => 0, ]; if ($dryRun) { foreach (data_get($bundle, 'projects', []) as $project) { $created['projects']++; foreach (data_get($project, 'environments', []) as $environment) { $created['environments']++; $created['applications'] += count(data_get($environment, 'applications', [])); $created['databases'] += count(data_get($environment, 'databases', [])); $created['services'] += count(data_get($environment, 'services', [])); foreach (data_get($environment, 'applications', []) as $app) { $created['previews'] += count(data_get($app, 'previews', [])); } } } $created['destinations'] = count(data_get($bundle, 'destinations', [])); $created['private_keys'] = max( count(data_get($bundle, 'private_keys', [])), data_get($bundle, 'private_key') ? 1 : 0 ); $created['github_apps'] = count(data_get($bundle, 'github_apps', [])); $created['gitlab_apps'] = count(data_get($bundle, 'gitlab_apps', [])); $created['gitea_apps'] = count(data_get($bundle, 'gitea_apps', [])); $created['s3_storages'] = count(data_get($bundle, 's3_storages', [])); $created['cloud_provider_tokens'] = count(data_get($bundle, 'cloud_provider_tokens', [])); $created['integration_tokens'] = count(data_get($bundle, 'integration_tokens', [])); $created['managed_dns_records'] = count(data_get($bundle, 'managed_dns_records', [])); $created['ssl_certificates'] = count(data_get($bundle, 'ssl_certificates', [])); $created['volume_backups'] = count(data_get($bundle, 'volume_backups', [])); return [ 'dry_run' => true, 'warnings' => $warnings, 'server_uuid' => $preserveUuids ? $serverUuid : null, 'private_key_uuid' => data_get($bundle, 'private_key.uuid'), 'created' => $created, 'preserved_uuids' => $preserveUuids, 'export_id' => data_get($bundle, 'export_id'), 'claimed' => false, 'claim' => null, 'checklist' => $this->postTransferChecklist($bundle), ]; } $result = DB::transaction(function () use ($bundle, $teamId, $preserveUuids, $adoptMode, $warnings, $archive, &$created) { // Removed in the same transaction as the import, so a failed import keeps the archive. if ($archive) { app(ServerTransferClaimer::class)->deleteArchive($archive); } Team::ensureServerCapacity($teamId); $this->privateKeyMap = []; $this->githubAppMap = []; $this->gitlabAppMap = []; $this->giteaAppMap = []; $this->s3StorageMap = []; $this->cloudTokenMap = []; $this->integrationTokenMap = []; $this->dnsZoneMap = []; $this->pendingDnsAdoptions = []; $this->pendingProjectIcons = []; $this->volumeMap = []; $this->applicationMap = []; $this->previewMap = []; $this->serviceMap = []; $this->serviceApplicationMap = []; $this->databaseMap = []; $this->pendingSqliteLinks = []; $this->importWarnings = []; $this->gitSourceApplications = []; // Import shared dependencies first $keyPayloads = data_get($bundle, 'private_keys', []); if ($keyPayloads === [] && data_get($bundle, 'private_key')) { $keyPayloads = [data_get($bundle, 'private_key')]; } foreach ($keyPayloads as $keyPayload) { $key = $this->importPrivateKey($keyPayload, $teamId, $preserveUuids); $this->privateKeyMap[(string) data_get($keyPayload, 'uuid', $key->uuid)] = $key; $this->privateKeyMap[$key->uuid] = $key; $created['private_keys']++; } foreach (data_get($bundle, 'github_apps', []) as $ghPayload) { // Defensive: never import system-wide GitHub Apps from a bundle. if ((bool) data_get($ghPayload, 'is_system_wide', false)) { continue; } $gh = $this->importGithubApp($ghPayload, $teamId, $preserveUuids); $this->githubAppMap[(string) data_get($ghPayload, 'uuid', $gh->uuid)] = $gh; $this->githubAppMap[$gh->uuid] = $gh; $created['github_apps']++; } foreach (data_get($bundle, 'gitlab_apps', []) as $glPayload) { // Defensive: never import system-wide GitLab Apps from a bundle. if ((bool) data_get($glPayload, 'is_system_wide', false)) { continue; } $gl = $this->importGitlabApp($glPayload, $teamId, $preserveUuids); $this->gitlabAppMap[(string) data_get($glPayload, 'uuid', $gl->uuid)] = $gl; $this->gitlabAppMap[$gl->uuid] = $gl; $created['gitlab_apps']++; } foreach (data_get($bundle, 'gitea_apps', []) as $gtPayload) { // Defensive: never import system-wide Gitea Apps from a bundle. if ((bool) data_get($gtPayload, 'is_system_wide', false)) { continue; } $gt = $this->importGiteaApp($gtPayload, $teamId, $preserveUuids); $this->giteaAppMap[(string) data_get($gtPayload, 'uuid', $gt->uuid)] = $gt; $this->giteaAppMap[$gt->uuid] = $gt; $created['gitea_apps']++; } foreach (data_get($bundle, 's3_storages', []) as $s3Payload) { $s3 = $this->importS3Storage($s3Payload, $teamId, $preserveUuids); $this->s3StorageMap[(string) data_get($s3Payload, 'uuid', $s3->uuid)] = $s3; $this->s3StorageMap[$s3->uuid] = $s3; $created['s3_storages']++; } foreach (data_get($bundle, 'cloud_provider_tokens', []) as $tokenPayload) { $token = $this->importCloudProviderToken($tokenPayload, $teamId, $preserveUuids); $this->cloudTokenMap[(string) data_get($tokenPayload, 'uuid', $token->uuid)] = $token; $this->cloudTokenMap[$token->uuid] = $token; $created['cloud_provider_tokens']++; } foreach (data_get($bundle, 'integration_tokens', []) as $tokenPayload) { $token = $this->importIntegrationToken($tokenPayload, $teamId, $preserveUuids); $this->integrationTokenMap[(string) data_get($tokenPayload, 'uuid', $token->uuid)] = $token; $this->integrationTokenMap[$token->uuid] = $token; $created['integration_tokens']++; } $serverKeyUuid = (string) data_get($bundle, 'private_key.uuid', ''); $privateKey = $this->privateKeyMap[$serverKeyUuid] ?? $this->importPrivateKey(data_get($bundle, 'private_key', []), $teamId, $preserveUuids); $server = $this->importServer(data_get($bundle, 'server', []), $privateKey, $teamId, $preserveUuids, $adoptMode); $destinationMap = $this->importDestinations(data_get($bundle, 'destinations', []), $server, $preserveUuids); $created['destinations'] = count($destinationMap); $this->importGithubRunnerConfig(data_get($bundle, 'github_runner_config'), $server, $teamId, $preserveUuids); $this->importServerSharedEnvVars(data_get($bundle, 'shared_environment_variables.server', []), $server, $teamId); $this->importTeamSharedEnvVars(data_get($bundle, 'shared_environment_variables.team', []), $teamId); foreach (data_get($bundle, 'projects', []) as $projectPayload) { $project = $this->importProject($projectPayload, $teamId, $preserveUuids, $created); foreach (data_get($projectPayload, 'environments', []) as $environmentPayload) { $environment = $this->importEnvironment($environmentPayload, $project, $preserveUuids, $created); foreach (data_get($environmentPayload, 'applications', []) as $appPayload) { $app = $this->importApplication($appPayload, $environment, $destinationMap, $preserveUuids, $adoptMode, $teamId); $this->applicationMap[(string) data_get($appPayload, 'uuid', $app->uuid)] = $app; $created['applications']++; $created['previews'] += count(data_get($appPayload, 'previews', [])); } foreach (data_get($environmentPayload, 'databases', []) as $dbPayload) { $db = $this->importDatabase($dbPayload, $environment, $destinationMap, $preserveUuids, $adoptMode, $teamId); if ($db) { $this->databaseMap[(string) data_get($dbPayload, 'uuid', $db->uuid)] = $db; } $created['databases']++; } foreach (data_get($environmentPayload, 'services', []) as $servicePayload) { $service = $this->importService($servicePayload, $environment, $server, $destinationMap, $preserveUuids, $adoptMode, $teamId); $this->serviceMap[(string) data_get($servicePayload, 'uuid', $service->uuid)] = $service; $created['services']++; } $this->importCanvasPositions((array) data_get($environmentPayload, 'canvas_positions', []), $environment); $this->importResourceLinks((array) data_get($environmentPayload, 'resource_links', []), $environment, $preserveUuids); } } $warnings = array_merge($warnings, $this->linkSqliteVolumes()); $this->importDnsZones(data_get($bundle, 'dns_zones', []), $preserveUuids); $created['managed_dns_records'] = $this->importManagedDnsRecords(data_get($bundle, 'managed_dns_records', []), $server, $teamId, $preserveUuids); $created['ssl_certificates'] = $this->importSslCertificates(data_get($bundle, 'ssl_certificates', []), $server); $created['volume_backups'] = $this->importVolumeBackups(data_get($bundle, 'volume_backups', []), $teamId); $warnings = array_merge($warnings, $this->importWarnings); $metadata = $server->server_metadata ?? []; $metadata['transfer'] = [ 'status' => 'imported', 'export_id' => data_get($bundle, 'export_id'), 'source_instance_url' => data_get($bundle, 'source_instance.url'), 'imported_at' => now()->toIso8601String(), 'adopt_mode' => $adoptMode, 'git_source_applications' => array_values(array_unique($this->gitSourceApplications)), ]; $server->server_metadata = $metadata; $server->save(); return [ 'dry_run' => false, 'warnings' => array_values(array_unique($warnings)), 'server_uuid' => $server->uuid, 'private_key_uuid' => $privateKey->uuid, 'created' => $created, 'preserved_uuids' => $preserveUuids, 'export_id' => data_get($bundle, 'export_id'), 'claimed' => false, 'claim' => null, 'checklist' => $this->postTransferChecklist($bundle), ]; }); // Provider and storage calls run after the import transaction commits, so an error cannot roll back DB rows. $result['warnings'] = array_values(array_unique(array_merge($result['warnings'], $this->adoptManagedDnsRecords(), $this->storeProjectIcons()))); // Claim after the import transaction commits so a claim failure cannot roll back DB rows. if (filled(data_get($result, 'server_uuid'))) { $server = Server::where('uuid', $result['server_uuid'])->where('team_id', $teamId)->first(); if ($server) { try { $result['claim'] = app(ServerTransferClaimer::class)->claim($server); $result['claimed'] = true; // Same check as the Validate button. A running proxy and Docker are kept as they are. ValidateAndInstallServerJob::dispatch($server); $this->startFinishChecklist($server); $result['server_url'] = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/').'/server/'.$server->uuid; } catch (Throwable $e) { $result['claimed'] = false; $result['claim'] = null; $result['warnings'][] = 'Server imported, but automatic claim failed: '.$e->getMessage(); } } } return $result; } /** * Check the server connection fields with the same rules as the create server API. * * @param array $server */ private function assertValidServerPayload(array $server): void { Validator::make($server, [ 'name' => 'nullable|string|max:255', 'ip' => ['required', 'string', new ValidServerIp], 'port' => 'required|integer|between:1,65535', 'user' => ValidationPatterns::serverUsernameRules(required: false), ], [], [ 'ip' => 'server.ip', 'port' => 'server.port', 'user' => 'server.user', ])->validate(); } /** * Checks that a server can be imported into the team, without the bundle. Every check runs, so the * source instance can show which checks are OK and which failed. * * @return list */ public function importChecks(string $serverUuid, string $serverIp, int $teamId, bool $preserveUuids = true): array { $team = Team::find($teamId); $archive = $preserveUuids ? $this->replaceableArchive($serverUuid, $teamId) : null; // An archive does not use a server slot, so replacing it also needs a free slot. $limitReached = ! $team || Team::serverLimitReached($team); $existingServer = $preserveUuids && $archive === null ? Server::withTrashed()->where('uuid', $serverUuid)->first() : null; $uuidMessage = match (true) { $existingServer === null => null, $existingServer->trashed() => "The server with UUID {$serverUuid} is still being deleted on this instance. Wait a minute, then transfer again.", $existingServer->isTransferredAway() => 'Another team of this instance has the archived copy of this server. Transfer the server into that team, or delete the archive there first.', default => "A server with UUID {$serverUuid} already exists on this instance. Delete/transfer it first, or import with preserve_uuids=false.", }; $ipExists = Server::where('ip', Server::normalizeIp($serverIp))->when($archive, fn ($query) => $query->whereKeyNot($archive->id))->exists(); return [ [ 'field' => 'server', 'label' => 'the team can have one more server', 'ok' => ! $limitReached, 'message' => $limitReached ? 'Server limit reached for your subscription.' : null, ], [ 'field' => 'server.uuid', 'label' => $archive ? 'the archived copy of this server on this instance is replaced' : 'no server with the same UUID exists', 'ok' => $uuidMessage === null, 'message' => $uuidMessage, ], [ 'field' => 'server.ip', 'label' => 'no server with the same IP exists', 'ok' => ! $ipExists, 'message' => $ipExists ? "A server with IP/domain {$serverIp} already exists on this instance. Remove it first." : null, ], ]; } /** * The steps that finish the transfer here, and one notification that points the team to them. * A failure here never fails the import: the server is imported and claimed already. */ private function startFinishChecklist(Server $server): void { try { $items = app(TransferFinishChecklist::class)->start($server); $server->team?->notify(new GeneralNotification( "Server '{$server->name}' was transferred to this instance. Open the server to finish the transfer: ".count($items).' steps to check.' )); } catch (Throwable $e) { Log::warning('Could not start the transfer finish checklist', ['server_uuid' => $server->uuid, 'error' => $e->getMessage()]); } } /** * The archive that this instance kept when it transferred the server away. A transfer back into the same team * replaces it. */ private function replaceableArchive(string $serverUuid, int $teamId): ?Server { $server = Server::query()->where('uuid', $serverUuid)->where('team_id', $teamId)->first(); return $server?->isTransferredAway() ? $server : null; } /** * @throws ValidationException with the first failed import check */ public function assertCanImport(string $serverUuid, string $serverIp, int $teamId, bool $preserveUuids = true): void { foreach ($this->importChecks($serverUuid, $serverIp, $teamId, $preserveUuids) as $check) { if (! $check['ok']) { throw ValidationException::withMessages([$check['field'] => [$check['message']]]); } } } /** * Running containers are found by the resource UUID. In adopt mode a new UUID would leave them * without a resource, so a conflict stops the import instead. * * @param class-string $modelClass */ private function resolveResourceUuid(string $modelClass, string $uuid, bool $adoptMode, string $label): string { if (! $modelClass::withTrashed()->where('uuid', $uuid)->exists()) { return $uuid; } if ($adoptMode) { throw ValidationException::withMessages([ 'bundle' => ["The {$label} UUID {$uuid} cannot be used on this instance. Adopt mode needs the same UUID to keep the running containers. If you deleted the {$label} on this instance, delete it permanently first."], ]); } return new_public_id(); } /** * @param array $payload */ private function importPrivateKey(array $payload, int $teamId, bool $preserveUuids): PrivateKey { $material = (string) data_get($payload, 'private_key'); if ($material === '') { throw new RuntimeException('Private key material is required.'); } $fingerprint = PrivateKey::generateFingerprint($material) ?? data_get($payload, 'fingerprint'); if ($fingerprint) { // Keys are unique per team, so only a key of the target team can be reused. $existing = PrivateKey::query() ->where('team_id', $teamId) ->where('fingerprint', $fingerprint) ->first(); if ($existing) { return $existing; } } $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); if (PrivateKey::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $key = new PrivateKey([ 'name' => data_get($payload, 'name') ?: 'Imported transfer key', 'description' => data_get($payload, 'description'), 'private_key' => $material, 'team_id' => $teamId, 'is_git_related' => (bool) data_get($payload, 'is_git_related', false), ]); $key->uuid = $uuid; try { $key->save(); } catch (Throwable $e) { // Retry once without forcing uuid if uniqueness/validation conflicts. $key->uuid = new_public_id(); $key->save(); } return $key->fresh(); } /** * @param array $payload */ private function importServer(array $payload, PrivateKey $privateKey, int $teamId, bool $preserveUuids, bool $adoptMode): Server { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); if (Server::withTrashed()->where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $cloudTokenId = null; $cloudTokenUuid = data_get($payload, 'cloud_provider_token_uuid'); if ($cloudTokenUuid && isset($this->cloudTokenMap[$cloudTokenUuid])) { $cloudTokenId = $this->cloudTokenMap[$cloudTokenUuid]->id; } $server = new Server; $server->forceFill([ 'name' => data_get($payload, 'name') ?: generate_random_name(), 'description' => data_get($payload, 'description'), 'ip' => data_get($payload, 'ip'), 'port' => (int) data_get($payload, 'port', 22), 'user' => data_get($payload, 'user') ?: 'root', 'private_key_id' => $privateKey->id, 'team_id' => $teamId, 'cloud_provider_token_id' => $cloudTokenId, 'hetzner_server_id' => data_get($payload, 'hetzner_server_id'), 'vultr_instance_id' => data_get($payload, 'vultr_instance_id'), 'digitalocean_droplet_id' => data_get($payload, 'digitalocean_droplet_id'), 'hostinger_virtual_machine_id' => data_get($payload, 'hostinger_virtual_machine_id'), 'proxy_error_page' => data_get($payload, 'proxy_error_page'), 'swarm_cluster' => data_get($payload, 'swarm_cluster'), ]); $server->uuid = $uuid; $server->save(); if ($server->settings) { $serverRole = data_get($payload, 'server_role'); if (! in_array($serverRole, array_column(ServerRole::cases(), 'value'), true)) { $serverRole = data_get($payload, 'is_build_server') ? ServerRole::BUILD->value : ServerRole::BOTH->value; } $server->settings->server_role = $serverRole; $server->settings->is_build_server = $serverRole === ServerRole::BUILD->value; $server->settings->save(); } $proxy = data_get($payload, 'proxy', []); if (is_array($proxy) && $proxy !== []) { foreach ($proxy as $key => $value) { $server->proxy->set($key, $value); } $server->save(); } $settingsPayload = data_get($payload, 'settings', []); if (is_array($settingsPayload) && $server->settings) { $safe = collect($settingsPayload) ->except([ 'id', 'server_id', 'created_at', 'updated_at', 'is_reachable', 'is_usable', 'force_disabled', 'sentinel_token', 'sentinel_custom_url', // A foreign key of the source instance; older bundles still contain it. 'cloudflare_tunnel_integration_token_id', 'cloudflare_tunnel_integration_token_uuid', 'patch_check_result', 'patch_check_error', 'patch_checked_at', ]) ->all(); $server->settings->fill($safe); $server->settings->cloudflare_tunnel_integration_token_id = $this->importedIntegrationTokenId( data_get($settingsPayload, 'cloudflare_tunnel_integration_token_uuid'), 'The Cloudflare tunnel of this server: its Cloudflare API token was not found on this instance; select it again in the Cloudflare tunnel settings.', ); // Imported servers start not validated; claim will rebind sentinel. $server->settings->is_reachable = false; $server->settings->is_usable = false; $server->settings->force_disabled = false; $server->settings->is_sentinel_enabled = false; $server->settings->save(); } if ($adoptMode) { // Do not trigger validation/install automatically; operator claims next. $server->settings->is_reachable = false; $server->settings->is_usable = false; $server->settings->save(); } return $server->fresh(['settings', 'standaloneDockers', 'swarmDockers']); } /** * @param list> $destinations * @return array keyed by original uuid */ private function importDestinations(array $destinations, Server $server, bool $preserveUuids): array { $map = []; $existingStandalone = $server->standaloneDockers->values(); $existingSwarm = $server->swarmDockers->values(); $standaloneIndex = 0; $swarmIndex = 0; if ($destinations === []) { $first = $existingStandalone->first() ?? $existingSwarm->first(); if ($first) { $map[$first->uuid] = $first; } return $map; } foreach ($destinations as $destination) { $type = data_get($destination, 'type', 'standalone'); $originalUuid = (string) data_get($destination, 'uuid'); $uuid = $preserveUuids && $originalUuid !== '' ? $originalUuid : new_public_id(); if ($type === 'swarm') { $model = $existingSwarm->get($swarmIndex); $swarmIndex++; if ($model) { $model->forceFill([ 'uuid' => SwarmDocker::where('uuid', $uuid)->where('id', '!=', $model->id)->exists() ? $model->uuid : $uuid, 'name' => data_get($destination, 'name') ?: $model->name, 'network' => data_get($destination, 'network') ?: $model->network, ])->saveQuietly(); } else { $model = new SwarmDocker; $model->forceFill([ 'uuid' => SwarmDocker::where('uuid', $uuid)->exists() ? new_public_id() : $uuid, 'name' => data_get($destination, 'name') ?: 'coolify-overlay', 'network' => data_get($destination, 'network') ?: 'coolify-overlay', 'server_id' => $server->id, ])->saveQuietly(); } } else { $model = $existingStandalone->get($standaloneIndex); $standaloneIndex++; if ($model) { $targetUuid = StandaloneDocker::where('uuid', $uuid)->where('id', '!=', $model->id)->exists() ? $model->uuid : $uuid; $model->forceFill([ 'uuid' => $targetUuid, 'name' => data_get($destination, 'name') ?: $model->name, 'network' => data_get($destination, 'network') ?: $model->network, ])->saveQuietly(); } else { $model = new StandaloneDocker; $model->forceFill([ 'uuid' => StandaloneDocker::where('uuid', $uuid)->exists() ? new_public_id() : $uuid, 'name' => data_get($destination, 'name') ?: 'coolify', 'network' => data_get($destination, 'network') ?: 'coolify', 'server_id' => $server->id, ])->saveQuietly(); } } $map[$originalUuid !== '' ? $originalUuid : $model->uuid] = $model->fresh(); } // The created hook of the server made a default destination; the server gets only the destinations of the bundle. StandaloneDocker::query()->whereKey($existingStandalone->slice($standaloneIndex)->modelKeys())->delete(); SwarmDocker::query()->whereKey($existingSwarm->slice($swarmIndex)->modelKeys())->delete(); return $map; } /** * @param list> $variables */ private function importServerSharedEnvVars(array $variables, Server $server, int $teamId): void { foreach ($variables as $variable) { $this->createSharedVariable($variable, ['type' => 'server', 'server_id' => $server->id, 'team_id' => $teamId]); } } /** * A team variable that already exists keeps the value of this instance. * * @param list> $variables */ private function importTeamSharedEnvVars(array $variables, int $teamId): void { foreach ($variables as $variable) { $key = (string) data_get($variable, 'key'); $exists = SharedEnvironmentVariable::query() ->where('type', 'team') ->where('team_id', $teamId) ->where('key', $key) ->exists(); if ($exists) { $this->importWarnings[] = "Team shared variable {$key} already exists on this instance. It keeps its value here, which can differ from the value on the source instance."; continue; } $this->createSharedVariable($variable, ['type' => 'team', 'team_id' => $teamId]); } } /** * @param array $variable A shared variable of the bundle. * @param array $scope The type, the team, and the server, project, or environment of the variable. */ private function createSharedVariable(array $variable, array $scope): void { $shared = new SharedEnvironmentVariable([ 'value' => data_get($variable, 'value'), 'is_multiline' => (bool) data_get($variable, 'is_multiline', false), 'is_literal' => (bool) data_get($variable, 'is_literal', false), 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false), 'comment' => data_get($variable, 'comment'), ...$scope, ]); $this->keepVariableKey($shared, (string) data_get($variable, 'key')); $shared->save(); } /** * Sets the key of a variable as it is on the source. The key setter rejects names that only older Coolify * versions accepted (such as my-var); deployments skip those with a warning, so the transfer keeps them. */ private function keepVariableKey(EnvironmentVariable|SharedEnvironmentVariable $variable, string $key): void { $variable->setRawAttributes(['key' => $key] + $variable->getAttributes()); } /** * @param array $payload * @param array $created */ private function importProject(array $payload, int $teamId, bool $preserveUuids, array &$created): Project { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $icon = data_get($payload, 'icon'); $existing = Project::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { $this->importProjectSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $existing, $teamId); // An icon that the project already has on this instance is kept. if (is_array($icon) && blank($existing->icon_path)) { $this->pendingProjectIcons[] = ['project' => $existing, 'icon' => $icon]; } return $existing; } if (Project::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $project = Project::create([ 'uuid' => $uuid, 'name' => data_get($payload, 'name') ?: generate_random_name(), 'description' => data_get($payload, 'description'), 'team_id' => $teamId, ]); $created['projects']++; $this->importProjectSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $project, $teamId); $project = $project->fresh(['environments']); if (is_array($icon)) { $this->pendingProjectIcons[] = ['project' => $project, 'icon' => $icon]; } return $project; } /** * Stores the icons of the imported projects in the icon storage of this instance. Coolify stores every * icon as a JPEG file and serves it as one, so other content is not stored. * * @return list warnings */ private function storeProjectIcons(): array { $warnings = []; foreach ($this->pendingProjectIcons as ['project' => $project, 'icon' => $icon]) { $contents = base64_decode((string) data_get($icon, 'content_base64', ''), true); $problem = match (true) { ! is_string($contents) || $contents === '' => 'its content is not valid', strlen($contents) > ServerTransferExporter::MAX_PROJECT_ICON_BYTES => 'it is larger than 2 MB', (new \finfo(FILEINFO_MIME_TYPE))->buffer($contents) !== 'image/jpeg' => 'it is not a JPEG image', default => null, }; if ($problem === null) { try { app(ProjectIconStorageService::class)->storeProjectContents($project, $contents); continue; } catch (Throwable) { $problem = 'the icon storage of this instance is not available'; } } $warnings[] = "The icon of project {$project->name} was not imported, because {$problem}. Upload it again in the project settings."; } $this->pendingProjectIcons = []; return $warnings; } /** * Manual steps after the transfer, with the URL of this instance in place of {target_url}. * * @param array $bundle * @return list */ private function postTransferChecklist(array $bundle): array { $targetUrl = rtrim((string) (instanceSettings()->fqdn ?: config('app.url')), '/'); return array_values(array_unique(array_map( fn (string $step) => str_replace('{target_url}', $targetUrl, $step), array_filter((array) data_get($bundle, 'post_transfer_checklist', []), 'is_string'), ))); } /** * The config is imported disabled: an enabled config makes this instance remove every runner container on * the server that it does not know, also the runners that the source started. The user enables it after * the GitHub App sends its webhooks here. */ private function importGithubRunnerConfig(mixed $payload, Server $server, int $teamId, bool $preserveUuids): void { if (! is_array($payload)) { return; } $appUuid = (string) data_get($payload, 'github_app_uuid', ''); $githubApp = $appUuid === '' ? null : ($this->githubAppMap[$appUuid] ?? GithubApp::query()->where('uuid', $appUuid)->where('is_system_wide', true)->first() ?? GithubApp::query()->where('uuid', $appUuid)->where('team_id', $teamId)->first()); if (! $githubApp) { $this->importWarnings[] = 'The GitHub runner settings of this server were not imported, because their GitHub App was not found on this instance. Set up GitHub runners on the server again.'; return; } $validator = Validator::make($payload, [ 'labels' => ['required', 'array', 'min:1'], 'labels.*' => ['string', 'regex:/\A[a-z0-9][a-z0-9._-]{0,99}\z/'], 'max_runners' => ['required', 'integer', 'min:1', 'max:32'], 'docker_mode' => ['required', Rule::enum(GithubRunnerDockerMode::class)], 'runner_image' => ['nullable', 'string', 'max:255', new DockerImageFormat], 'cpu_limit' => ['nullable', 'string', 'regex:/\A\d+(\.\d+)?\z/'], 'memory_limit' => ['nullable', 'string', 'regex:/\A\d+[bkmg]?\z/i'], 'capacity_wait_timeout' => ['required', 'integer', 'min:1', 'max:1440'], 'idle_timeout' => ['required', 'integer', 'min:1', 'max:1440'], 'job_timeout' => ['required', 'integer', 'min:1', 'max:7200'], ]); if ($validator->fails()) { $this->importWarnings[] = 'The GitHub runner settings of this server were not imported, because they are not valid: '.$validator->errors()->first().' Set up GitHub runners on the server again.'; return; } $uuid = (string) data_get($payload, 'uuid', ''); $config = new GithubRunnerConfig; $config->forceFill([ 'server_id' => $server->id, 'github_app_id' => $githubApp->id, 'labels' => array_values($payload['labels']), 'is_enabled' => false, 'is_dedicated' => (bool) data_get($payload, 'is_dedicated', false), 'allow_pull_requests' => (bool) data_get($payload, 'allow_pull_requests', false), 'max_runners' => (int) $payload['max_runners'], 'docker_mode' => GithubRunnerDockerMode::from($payload['docker_mode']), 'runner_image' => data_get($payload, 'runner_image'), 'cpu_limit' => data_get($payload, 'cpu_limit'), 'memory_limit' => data_get($payload, 'memory_limit'), 'capacity_wait_timeout' => (int) $payload['capacity_wait_timeout'], 'idle_timeout' => (int) $payload['idle_timeout'], 'job_timeout' => (int) $payload['job_timeout'], ]); if ($preserveUuids && $uuid !== '' && ! GithubRunnerConfig::where('uuid', $uuid)->exists()) { $config->uuid = $uuid; } $config->save(); } /** * @param list> $variables */ private function importProjectSharedEnvVars(array $variables, Project $project, int $teamId): void { foreach ($variables as $variable) { $exists = SharedEnvironmentVariable::query() ->where('type', 'project') ->where('project_id', $project->id) ->where('key', data_get($variable, 'key')) ->exists(); if ($exists) { continue; } $this->createSharedVariable($variable, ['type' => 'project', 'project_id' => $project->id, 'team_id' => $teamId]); } } /** * @param array $payload * @param array $created */ private function importEnvironment(array $payload, Project $project, bool $preserveUuids, array &$created): Environment { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $byUuid = Environment::where('uuid', $uuid)->where('project_id', $project->id)->first(); if ($byUuid) { $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $byUuid, $project->team_id); return $byUuid; } $name = (string) data_get($payload, 'name', 'production'); $byName = $project->environments()->where('name', $name)->first(); if ($byName) { if ($preserveUuids && $uuid !== '' && ! Environment::where('uuid', $uuid)->exists()) { $byName->uuid = $uuid; $byName->save(); } if (filled(data_get($payload, 'description'))) { $byName->description = data_get($payload, 'description'); $byName->save(); } $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $byName, $project->team_id); return $byName->fresh(); } if (Environment::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $environment = Environment::create([ 'uuid' => $uuid, 'name' => $name, 'description' => data_get($payload, 'description'), 'project_id' => $project->id, ]); $created['environments']++; $this->importEnvironmentSharedEnvVars(data_get($payload, 'shared_environment_variables', []), $environment, $project->team_id); return $environment; } /** * @param list> $variables */ private function importEnvironmentSharedEnvVars(array $variables, Environment $environment, int $teamId): void { foreach ($variables as $variable) { $exists = SharedEnvironmentVariable::query() ->where('type', 'environment') ->where('environment_id', $environment->id) ->where('key', data_get($variable, 'key')) ->exists(); if ($exists) { continue; } $this->createSharedVariable($variable, ['type' => 'environment', 'environment_id' => $environment->id, 'team_id' => $teamId]); } } /** * Canvas positions are keyed by resource uuid. Resources may get a new uuid on import. * * @param array $positions */ private function importCanvasPositions(array $positions, Environment $environment): void { $imported = []; foreach ($positions as $uuid => $position) { $resource = $this->applicationMap[$uuid] ?? $this->databaseMap[$uuid] ?? $this->serviceMap[$uuid] ?? null; if ($resource) { $imported[$resource->uuid] = $position; } } if ($imported === []) { return; } $environment->canvas_positions = array_merge($environment->canvas_positions ?? [], $imported); $environment->save(); } /** * Links between two imported resources of the environment. The user who drew the link is a user of the * source instance, so created_by stays empty. * * @param list> $links */ private function importResourceLinks(array $links, Environment $environment, bool $preserveUuids): void { foreach ($links as $link) { $source = $this->linkedResource(data_get($link, 'source')); $target = $this->linkedResource(data_get($link, 'target')); if (! $source || ! $target || $source->is($target) || (int) $source->environment_id !== $environment->id || (int) $target->environment_id !== $environment->id) { $this->importWarnings[] = "A link between resources on the canvas of environment {$environment->name} was not imported, because one of its resources was not imported."; continue; } $attributes = [ 'environment_id' => $environment->id, 'source_type' => $source->getMorphClass(), 'source_id' => $source->getKey(), 'target_type' => $target->getMorphClass(), 'target_id' => $target->getKey(), ]; if (ResourceLink::query()->where($attributes)->exists()) { continue; } $label = data_get($link, 'label'); $resourceLink = new ResourceLink([ ...$attributes, 'label' => is_string($label) && trim($label) !== '' ? mb_substr(trim($label), 0, 64) : null, 'created_by' => null, ]); $uuid = (string) data_get($link, 'uuid', ''); if ($preserveUuids && $uuid !== '' && ! ResourceLink::where('uuid', $uuid)->exists()) { $resourceLink->uuid = $uuid; } $resourceLink->save(); } } /** * An end of a canvas link: the kind and the original uuid of an imported resource. */ private function linkedResource(mixed $end): ?Model { $uuid = (string) data_get($end, 'uuid', ''); return match (data_get($end, 'kind')) { 'application' => $this->applicationMap[$uuid] ?? null, 'database' => $this->databaseMap[$uuid] ?? null, 'service' => $this->serviceMap[$uuid] ?? null, default => null, }; } /** * @param array $payload * @param array $destinationMap */ private function importApplication( array $payload, Environment $environment, array $destinationMap, bool $preserveUuids, bool $adoptMode, int $teamId, ): Application { $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap); $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $uuid = $this->resolveResourceUuid(Application::class, $uuid, $adoptMode, 'application'); $attributes = (array) data_get($payload, 'attributes', []); unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type'], $attributes['source_id'], $attributes['source_type'], $attributes['private_key_id']); $attributes = $this->onlyExistingColumns(Application::class, $attributes); $attributes['uuid'] = $uuid; $attributes['environment_id'] = $environment->id; $attributes['destination_id'] = $destination->id; $attributes['destination_type'] = $destination->getMorphClass(); $name = (string) data_get($attributes, 'name', $uuid); // Re-link git source $source = data_get($payload, 'source'); if (is_array($source) && filled(data_get($source, 'uuid'))) { $sourceUuid = (string) data_get($source, 'uuid'); $sourceType = (string) data_get($source, 'type'); if ($sourceType === 'github_app') { $gh = $this->githubAppMap[$sourceUuid] ?? GithubApp::query()->where('uuid', $sourceUuid)->where('is_system_wide', true)->first() ?? GithubApp::query()->where('uuid', $sourceUuid)->where('team_id', $teamId)->first(); if ($gh) { $attributes['source_type'] = GithubApp::class; $attributes['source_id'] = $gh->id; } } elseif ($sourceType === 'gitlab_app') { $gl = $this->gitlabAppMap[$sourceUuid] ?? GitlabApp::query()->where('uuid', $sourceUuid)->where('is_system_wide', true)->first() ?? GitlabApp::query()->where('uuid', $sourceUuid)->where('team_id', $teamId)->first(); if ($gl) { $attributes['source_type'] = GitlabApp::class; $attributes['source_id'] = $gl->id; } } elseif ($sourceType === 'gitea_app') { $gt = $this->giteaAppMap[$sourceUuid] ?? GiteaApp::query()->where('uuid', $sourceUuid)->where('is_system_wide', true)->first() ?? GiteaApp::query()->where('uuid', $sourceUuid)->where('team_id', $teamId)->first(); if ($gt) { $attributes['source_type'] = GiteaApp::class; $attributes['source_id'] = $gt->id; } } } $sourceMissing = data_get($payload, 'had_git_source') && ! isset($attributes['source_id']); if ($sourceMissing || data_get($payload, 'source.system_wide') === true) { $this->gitSourceApplications[] = $uuid; } if ($sourceMissing) { $sourceLabel = match (data_get($payload, 'source.type')) { 'github_app' => 'GitHub App', 'gitlab_app' => 'GitLab App', 'gitea_app' => 'Gitea App', default => 'git source', }; $this->importWarnings[] = "Application {$name}: its {$sourceLabel} was not found on this instance; set the source again."; } // Re-link deploy key $appKeyUuid = data_get($payload, 'private_key_uuid'); if ($appKeyUuid && isset($this->privateKeyMap[$appKeyUuid])) { $attributes['private_key_id'] = $this->privateKeyMap[$appKeyUuid]->id; } if (data_get($payload, 'had_private_key') && ! isset($attributes['private_key_id'])) { $this->importWarnings[] = "Application {$name}: its private key was not found on this instance; select the private key again."; } if ($adoptMode) { // Keep runtime status if provided so inventory can match, but default exited if empty. $attributes['status'] = data_get($attributes, 'status') ?: 'exited'; } else { $attributes['status'] = 'exited'; } $application = new Application($attributes); // Maintenance mode is not fillable. $application->forceFill(collect($attributes)->only(['is_maintenance_enabled', 'maintenance_page'])->all()); $application->save(); // The created hook gives a new application the newest compose parser and default variables. A transferred // application keeps its parser, which names its volumes and domains, and gets only the variables of the bundle. $application->forceFill(collect($attributes)->only('compose_parsing_version')->filter()->all())->saveQuietly(); EnvironmentVariable::query()->whereMorphedTo('resourceable', $application)->delete(); $settings = (array) data_get($payload, 'settings', []); if ($settings !== [] && $application->settings) { $portsExposes = $application->ports_exposes; $application->settings->fill(collect($settings)->except(['id', 'application_id'])->all()); $application->settings->save(); // The is_static setter sets the port of a static application to 80; the user can change it after that. $application->refresh()->forceFill(['ports_exposes' => $portsExposes])->saveQuietly(); } $this->importEnvVars(data_get($payload, 'environment_variables', []), $application, false); $this->importEnvVars(data_get($payload, 'environment_variables_preview', []), $application, true); $this->importPersistentStorages(data_get($payload, 'persistent_storages', []), $application); $this->importFileStorages(data_get($payload, 'file_storages', []), $application); $this->importScheduledTasks(data_get($payload, 'scheduled_tasks', []), $application, $teamId); $this->importTags(data_get($payload, 'tags', []), $application, $teamId); $this->importPreviews(data_get($payload, 'previews', []), $application, $preserveUuids, $adoptMode, $teamId); $this->importSecretManagerLink(data_get($payload, 'secret_manager_link'), $application, "Application {$name}"); return $application; } /** * @param array $payload * @param array $destinationMap */ private function importDatabase( array $payload, Environment $environment, array $destinationMap, bool $preserveUuids, bool $adoptMode, int $teamId = 0, ): ?Model { $type = (string) data_get($payload, 'type', 'StandalonePostgresql'); $modelClass = self::DATABASE_MODELS[$type] ?? null; if (! $modelClass) { throw new RuntimeException("Unsupported database type: {$type}"); } $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap); $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $uuid = $this->resolveResourceUuid($modelClass, $uuid, $adoptMode, 'database'); $attributes = (array) data_get($payload, 'attributes', []); unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type']); $attributes = $this->onlyExistingColumns($modelClass, $attributes); $attributes['uuid'] = $uuid; $attributes['environment_id'] = $environment->id; $attributes['destination_id'] = $destination->id; $attributes['destination_type'] = $destination->getMorphClass(); $attributes['status'] = $adoptMode ? (data_get($attributes, 'status') ?: 'exited') : 'exited'; // Avoid auto-created default volumes; we restore exported ones. $database = $modelClass::withoutEvents(function () use ($modelClass, $attributes, $uuid) { $database = new $modelClass; $database->forceFill(collect($attributes)->except(['uuid'])->all()); $database->uuid = $uuid; $database->save(); return $database; }); $this->importEnvVars(data_get($payload, 'environment_variables', []), $database, false); $this->importPersistentStorages(data_get($payload, 'persistent_storages', []), $database); $this->importFileStorages(data_get($payload, 'file_storages', []), $database); if (method_exists($database, 'tags')) { $this->importTags(data_get($payload, 'tags', []), $database, $teamId); } $this->importScheduledBackups(data_get($payload, 'scheduled_backups', []), $database, $teamId); $this->importSecretManagerLink(data_get($payload, 'secret_manager_link'), $database, "Database {$database->name}"); return $database; } /** * @param array $payload * @param array $destinationMap */ private function importService( array $payload, Environment $environment, Server $server, array $destinationMap, bool $preserveUuids, bool $adoptMode, int $teamId = 0, ): Service { $destination = $this->resolveDestination(data_get($payload, 'destination_uuid'), $destinationMap); $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $uuid = $this->resolveResourceUuid(Service::class, $uuid, $adoptMode, 'service'); $attributes = (array) data_get($payload, 'attributes', []); unset($attributes['id'], $attributes['environment_id'], $attributes['destination_id'], $attributes['destination_type'], $attributes['server_id']); $attributes = $this->onlyExistingColumns(Service::class, $attributes); $attributes['uuid'] = $uuid; $attributes['environment_id'] = $environment->id; $attributes['server_id'] = $server->id; $attributes['destination_id'] = $destination->id; $attributes['destination_type'] = $destination->getMorphClass(); $service = new Service($attributes); // Maintenance mode and the Coolify default variables switch are not fillable. $service->forceFill(collect($attributes)->only(['is_maintenance_enabled', 'maintenance_page', 'include_coolify_default_variables'])->all()); $service->save(); // The created hook gives a new service the newest compose parser; a transferred service keeps its own. $service->forceFill(collect($attributes)->only('compose_parsing_version')->filter()->all())->saveQuietly(); $this->importEnvVars(data_get($payload, 'environment_variables', []), $service, false); $this->importScheduledTasks(data_get($payload, 'scheduled_tasks', []), $service, $teamId); $this->importTags(data_get($payload, 'tags', []), $service, $teamId); $this->importSecretManagerLink(data_get($payload, 'secret_manager_link'), $service, "Service {$service->name}"); foreach (data_get($payload, 'applications', []) as $appPayload) { $serviceApp = $this->importServiceApplication($appPayload, $service, $preserveUuids, $adoptMode); $this->serviceApplicationMap[(string) data_get($appPayload, 'uuid', $serviceApp->uuid)] = $serviceApp; } foreach (data_get($payload, 'databases', []) as $dbPayload) { $this->importServiceDatabase($dbPayload, $service, $preserveUuids, $adoptMode, $teamId); } return $service; } /** * @param array $appPayload */ private function importServiceApplication(array $appPayload, Service $service, bool $preserveUuids, bool $adoptMode): ServiceApplication { $appUuid = $preserveUuids && filled(data_get($appPayload, 'uuid')) ? (string) data_get($appPayload, 'uuid') : new_public_id(); if (ServiceApplication::where('uuid', $appUuid)->exists()) { $appUuid = new_public_id(); } $attributes = (array) data_get($appPayload, 'attributes', []); if ($attributes === []) { // Back-compat with older thin service-application payloads. $attributes = collect($appPayload)->except([ 'uuid', 'environment_variables', 'persistent_storages', 'file_storages', 'attributes', ])->all(); } unset($attributes['id'], $attributes['service_id'], $attributes['created_at'], $attributes['updated_at'], $attributes['deleted_at']); $attributes = $this->onlyExistingColumns(ServiceApplication::class, $attributes); $attributes['service_id'] = $service->id; $attributes['name'] = data_get($attributes, 'name') ?: data_get($appPayload, 'name') ?: 'service-app'; $attributes['status'] = $adoptMode ? (data_get($attributes, 'status') ?: data_get($appPayload, 'status') ?: 'running:unknown') : 'exited:unhealthy'; $serviceApp = new ServiceApplication; $serviceApp->forceFill($attributes); $serviceApp->uuid = $appUuid; $serviceApp->save(); $this->importEnvVars(data_get($appPayload, 'environment_variables', []), $serviceApp, false); $this->importPersistentStorages(data_get($appPayload, 'persistent_storages', []), $serviceApp); $this->importFileStorages(data_get($appPayload, 'file_storages', []), $serviceApp); return $serviceApp; } /** * @param array $dbPayload */ private function importServiceDatabase(array $dbPayload, Service $service, bool $preserveUuids, bool $adoptMode, int $teamId): ServiceDatabase { $dbUuid = $preserveUuids && filled(data_get($dbPayload, 'uuid')) ? (string) data_get($dbPayload, 'uuid') : new_public_id(); if (ServiceDatabase::where('uuid', $dbUuid)->exists()) { $dbUuid = new_public_id(); } $attributes = (array) data_get($dbPayload, 'attributes', []); if ($attributes === []) { $attributes = collect($dbPayload)->except([ 'uuid', 'environment_variables', 'persistent_storages', 'file_storages', 'scheduled_backups', 'attributes', ])->all(); } unset($attributes['id'], $attributes['service_id'], $attributes['created_at'], $attributes['updated_at'], $attributes['deleted_at']); $attributes = $this->onlyExistingColumns(ServiceDatabase::class, $attributes); $attributes['service_id'] = $service->id; $attributes['name'] = data_get($attributes, 'name') ?: data_get($dbPayload, 'name') ?: 'service-db'; $attributes['status'] = $adoptMode ? (data_get($attributes, 'status') ?: data_get($dbPayload, 'status') ?: 'running:unknown') : 'exited:unhealthy'; $serviceDb = new ServiceDatabase; $serviceDb->forceFill($attributes); $serviceDb->uuid = $dbUuid; $serviceDb->save(); $this->importPersistentStorages(data_get($dbPayload, 'persistent_storages', []), $serviceDb); $this->importFileStorages(data_get($dbPayload, 'file_storages', []), $serviceDb); $this->importScheduledBackups(data_get($dbPayload, 'scheduled_backups', []), $serviceDb, $teamId); return $serviceDb; } /** * @param list> $variables */ private function importEnvVars(array $variables, object $resource, bool $isPreview): void { foreach ($variables as $variable) { EnvironmentVariable::withoutEvents(function () use ($variable, $resource, $isPreview) { $uuid = filled(data_get($variable, 'uuid')) ? (string) data_get($variable, 'uuid') : new_public_id(); if (EnvironmentVariable::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $env = new EnvironmentVariable; $env->forceFill([ 'value' => data_get($variable, 'value'), 'is_literal' => (bool) data_get($variable, 'is_literal', false), 'is_multiline' => (bool) data_get($variable, 'is_multiline', false), 'is_preview' => $isPreview || (bool) data_get($variable, 'is_preview', false), 'is_runtime' => (bool) data_get($variable, 'is_runtime', true), 'is_buildtime' => (bool) data_get($variable, 'is_buildtime', true), 'is_shown_once' => (bool) data_get($variable, 'is_shown_once', false), 'is_shared' => (bool) data_get($variable, 'is_shared', false), 'is_required' => (bool) data_get($variable, 'is_required', false), // Exports from older versions have no flag; their values use the old escaping. 'uses_legacy_escaping' => (bool) data_get($variable, 'uses_legacy_escaping', true), 'preserve_compose_null' => (bool) data_get($variable, 'preserve_compose_null', false), 'comment' => data_get($variable, 'comment'), 'order' => data_get($variable, 'order'), 'resourceable_type' => $resource->getMorphClass(), 'resourceable_id' => $resource->id, ]); $this->keepVariableKey($env, (string) data_get($variable, 'key')); // Older bundles have no version; the column default applies. if (filled(data_get($variable, 'version'))) { $env->version = (string) data_get($variable, 'version'); } $env->uuid = $uuid; $env->save(); }); } } /** * @param list> $volumes */ private function importPersistentStorages(array $volumes, object $resource): void { foreach ($volumes as $volume) { $uuid = filled(data_get($volume, 'uuid')) ? (string) data_get($volume, 'uuid') : new_public_id(); if (LocalPersistentVolume::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $volumeModel = new LocalPersistentVolume; $volumeModel->forceFill([ 'name' => data_get($volume, 'name'), 'mount_path' => data_get($volume, 'mount_path'), 'host_path' => data_get($volume, 'host_path'), 'is_preview_suffix_enabled' => (bool) data_get($volume, 'is_preview_suffix_enabled', false), // The server keeps its Docker volumes. A bundle without the flag is from a Coolify version that created them without driver options. 'ignores_compose_driver_options' => (bool) data_get($volume, 'ignores_compose_driver_options', true), 'resource_type' => $resource->getMorphClass(), 'resource_id' => $resource->id, ]); $volumeModel->uuid = $uuid; $volumeModel->save(); $this->volumeMap[$uuid] = $volumeModel; if (filled(data_get($volume, 'uuid'))) { $this->volumeMap[(string) data_get($volume, 'uuid')] = $volumeModel; } if (filled(data_get($volume, 'standalone_sqlite_uuid'))) { $this->pendingSqliteLinks[$volumeModel->id] = [ 'volume' => $volumeModel, 'sqlite_uuid' => (string) data_get($volume, 'standalone_sqlite_uuid'), ]; } } } /** * Connect imported volumes to the imported SQLite database whose data volume they mount. * * @return list warnings for volumes whose database is not in the bundle */ private function linkSqliteVolumes(): array { $warnings = []; foreach ($this->pendingSqliteLinks as $link) { $sqlite = $this->databaseMap[$link['sqlite_uuid']] ?? null; if (! $sqlite instanceof StandaloneSqlite) { $warnings[] = "Volume {$link['volume']->name} mounts a SQLite database that is not part of this transfer. Coolify does not protect it when that database or its applications are deleted."; continue; } $link['volume']->forceFill(['standalone_sqlite_id' => $sqlite->id])->save(); } return $warnings; } /** * @param list> $storages */ private function importFileStorages(array $storages, object $resource): void { foreach ($storages as $storage) { LocalFileVolume::withoutEvents(function () use ($storage, $resource) { $isHostFile = (bool) data_get($storage, 'is_host_file', false); $fsPath = data_get($storage, 'fs_path'); if (! is_string($fsPath)) { throw new RuntimeException('Invalid imported file storage path.'); } if ($isHostFile) { $fsPath = validateHostFileMountPath($fsPath, 'imported host file source path'); } $chown = data_get($storage, 'chown'); $chmod = data_get($storage, 'chmod'); if (filled($chown) && (! is_string($chown) || ! preg_match('/\A(?:[A-Za-z_][A-Za-z0-9_.-]*|[0-9]+)(?::(?:[A-Za-z_][A-Za-z0-9_.-]*|[0-9]+))?\z/', $chown))) { throw new RuntimeException('Invalid imported file owner.'); } if (filled($chmod) && (! is_string($chmod) || ! preg_match('/\A[0-7]{3,4}\z/', $chmod))) { throw new RuntimeException('Invalid imported file mode.'); } $uuid = filled(data_get($storage, 'uuid')) ? (string) data_get($storage, 'uuid') : new_public_id(); if (LocalFileVolume::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } // uuid is not fillable and withoutEvents skips BaseModel's creating hook. $file = new LocalFileVolume; $file->forceFill([ 'fs_path' => $fsPath, 'mount_path' => data_get($storage, 'mount_path'), 'content' => data_get($storage, 'content'), 'is_directory' => (bool) data_get($storage, 'is_directory', false), 'is_host_file' => $isHostFile, 'chown' => $chown, 'chmod' => $chmod, 'is_based_on_git' => (bool) data_get($storage, 'is_based_on_git', false), 'is_preview_suffix_enabled' => (bool) data_get($storage, 'is_preview_suffix_enabled', false), 'resource_type' => $resource->getMorphClass(), 'resource_id' => $resource->id, ]); $file->uuid = $uuid; $file->save(); $this->volumeMap[$uuid] = $file; if (filled(data_get($storage, 'uuid'))) { $this->volumeMap[(string) data_get($storage, 'uuid')] = $file; } }); } } /** * @param list> $tasks */ private function importScheduledTasks(array $tasks, Application|Service $resource, int $teamId): void { foreach ($tasks as $task) { $uuid = filled(data_get($task, 'uuid')) ? (string) data_get($task, 'uuid') : new_public_id(); if (ScheduledTask::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $payload = [ 'uuid' => $uuid, 'name' => data_get($task, 'name'), 'command' => data_get($task, 'command'), 'frequency' => data_get($task, 'frequency'), 'container' => data_get($task, 'container'), 'timeout' => data_get($task, 'timeout'), 'enabled' => (bool) data_get($task, 'enabled', true), 'team_id' => $teamId, ]; if ($resource instanceof Application) { $payload['application_id'] = $resource->id; } else { $payload['service_id'] = $resource->id; } ScheduledTask::create($payload); } } /** * @param list $tags */ private function importTags(array $tags, Model $resource, int $teamId): void { if ($tags === [] || ! method_exists($resource, 'tags')) { return; } foreach ($tags as $tagPayload) { $name = strtolower(trim((string) data_get($tagPayload, 'name', ''))); if ($name === '') { continue; } $uuid = filled(data_get($tagPayload, 'uuid')) ? (string) data_get($tagPayload, 'uuid') : new_public_id(); $tag = Tag::query() ->where('team_id', $teamId) ->where('name', $name) ->first(); if (! $tag) { // Prefer preserved uuid when free; otherwise create with a new one. if (Tag::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $tag = new Tag; $tag->forceFill([ 'name' => $name, 'team_id' => $teamId, ]); $tag->uuid = $uuid; $tag->save(); } $resource->tags()->syncWithoutDetaching([$tag->id]); } } /** * @param list> $backups */ private function importScheduledBackups(array $backups, Model $database, int $teamId): void { foreach ($backups as $backup) { $uuid = filled(data_get($backup, 'uuid')) ? (string) data_get($backup, 'uuid') : new_public_id(); if (ScheduledDatabaseBackup::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $s3Ids = $this->importedBackupS3StorageIds($backup); $s3Id = $s3Ids[0] ?? null; $this->warnAboutMissingS3Storage($backup, $s3Id, "database {$database->name}"); $importedBackup = ScheduledDatabaseBackup::create([ 'uuid' => $uuid, 'team_id' => $teamId, 'description' => data_get($backup, 'description'), 'enabled' => (bool) data_get($backup, 'enabled', true), 'save_s3' => (bool) data_get($backup, 'save_s3', false) && $s3Id !== null, 'frequency' => data_get($backup, 'frequency'), 'databases_to_backup' => data_get($backup, 'databases_to_backup'), 'dump_all' => (bool) data_get($backup, 'dump_all', false), 'database_backup_retention_amount_locally' => data_get($backup, 'database_backup_retention_amount_locally', 0), 'database_backup_retention_days_locally' => data_get($backup, 'database_backup_retention_days_locally'), 'database_backup_retention_max_storage_locally' => data_get($backup, 'database_backup_retention_max_storage_locally'), 'database_backup_retention_amount_s3' => data_get($backup, 'database_backup_retention_amount_s3'), 'database_backup_retention_days_s3' => data_get($backup, 'database_backup_retention_days_s3'), 'database_backup_retention_max_storage_s3' => data_get($backup, 'database_backup_retention_max_storage_s3'), 'timeout' => data_get($backup, 'timeout'), 'disable_local_backup' => (bool) data_get($backup, 'disable_local_backup', false), 'missing_backup_notification_days' => (int) data_get($backup, 'missing_backup_notification_days', 0), 's3_storage_id' => $s3Id, 'database_type' => $database->getMorphClass(), 'database_id' => $database->id, ]); $importedBackup->syncS3Storages($s3Ids); } } /** * @param array $backup */ private function warnAboutMissingS3Storage(array $backup, ?int $s3Id, string $backupOf): void { if (! data_get($backup, 'had_s3_storage') || $s3Id !== null) { return; } $this->importWarnings[] = data_get($backup, 'save_s3') ? "Backup of {$backupOf}: S3 upload was turned off because its S3 storage was not found." : "Backup of {$backupOf}: its S3 storage was not found; select it again."; } /** * Maps the exported S3 destinations of a backup to imported storages, primary first. Older bundles only have * `s3_storage_uuid`. * * @param array $backup * @return list */ private function importedBackupS3StorageIds(array $backup): array { $uuids = collect(data_get($backup, 's3_storage_uuids', [])) ->prepend(data_get($backup, 's3_storage_uuid')) ->filter(fn ($uuid): bool => is_string($uuid) && isset($this->s3StorageMap[$uuid])); return $uuids->map(fn (string $uuid): int => $this->s3StorageMap[$uuid]->id)->unique()->values()->all(); } /** * @param array $payload */ private function importGithubApp(array $payload, int $teamId, bool $preserveUuids): GithubApp { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = GithubApp::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } if (GithubApp::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $privateKeyId = null; $keyUuid = data_get($payload, 'private_key_uuid'); if ($keyUuid && isset($this->privateKeyMap[$keyUuid])) { $privateKeyId = $this->privateKeyMap[$keyUuid]->id; } $app = new GithubApp; $app->forceFill([ 'team_id' => $teamId, 'private_key_id' => $privateKeyId, 'name' => data_get($payload, 'name') ?: 'Imported GitHub App', 'organization' => data_get($payload, 'organization'), 'api_url' => data_get($payload, 'api_url') ?: 'https://api.github.com', 'html_url' => data_get($payload, 'html_url') ?: 'https://github.com', 'custom_user' => data_get($payload, 'custom_user'), 'custom_port' => data_get($payload, 'custom_port'), 'app_id' => data_get($payload, 'app_id'), 'installation_id' => data_get($payload, 'installation_id'), 'client_id' => data_get($payload, 'client_id'), 'client_secret' => data_get($payload, 'client_secret'), 'webhook_secret' => data_get($payload, 'webhook_secret'), 'is_system_wide' => false, 'is_public' => (bool) data_get($payload, 'is_public', false), 'contents' => data_get($payload, 'contents'), 'metadata' => data_get($payload, 'metadata'), 'pull_requests' => data_get($payload, 'pull_requests'), 'administration' => data_get($payload, 'administration'), 'organization_self_hosted_runners' => data_get($payload, 'organization_self_hosted_runners'), 'actions' => data_get($payload, 'actions'), 'webhook_events' => data_get($payload, 'webhook_events'), 'runner_group_id' => data_get($payload, 'runner_group_id'), ]); $app->uuid = $uuid; $app->save(); return $app; } /** * @param array $payload */ private function importGitlabApp(array $payload, int $teamId, bool $preserveUuids): GitlabApp { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = GitlabApp::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } if (GitlabApp::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $privateKeyId = null; $keyUuid = data_get($payload, 'private_key_uuid'); if ($keyUuid && isset($this->privateKeyMap[$keyUuid])) { $privateKeyId = $this->privateKeyMap[$keyUuid]->id; } $app = new GitlabApp; $app->forceFill([ 'team_id' => $teamId, 'private_key_id' => $privateKeyId, 'name' => data_get($payload, 'name') ?: 'Imported GitLab App', 'organization' => data_get($payload, 'organization'), 'api_url' => data_get($payload, 'api_url'), 'html_url' => data_get($payload, 'html_url'), 'custom_port' => data_get($payload, 'custom_port'), 'custom_user' => data_get($payload, 'custom_user'), 'is_system_wide' => false, 'is_public' => (bool) data_get($payload, 'is_public', false), 'app_id' => data_get($payload, 'app_id'), 'app_secret' => data_get($payload, 'app_secret'), 'oauth_id' => data_get($payload, 'oauth_id'), 'client_id' => data_get($payload, 'client_id'), 'client_secret' => data_get($payload, 'client_secret'), 'access_token' => data_get($payload, 'access_token'), 'refresh_token' => data_get($payload, 'refresh_token'), 'expires_at' => data_get($payload, 'expires_at'), 'redirect_uri' => data_get($payload, 'redirect_uri'), 'group_name' => data_get($payload, 'group_name'), 'public_key' => data_get($payload, 'public_key'), 'webhook_token' => data_get($payload, 'webhook_token'), 'deploy_key_id' => data_get($payload, 'deploy_key_id'), ]); $app->uuid = $uuid; $app->save(); return $app; } /** * @param array $payload */ private function importGiteaApp(array $payload, int $teamId, bool $preserveUuids): GiteaApp { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = GiteaApp::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } if (GiteaApp::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $privateKeyId = null; $keyUuid = data_get($payload, 'private_key_uuid'); if ($keyUuid && isset($this->privateKeyMap[$keyUuid])) { $privateKeyId = $this->privateKeyMap[$keyUuid]->id; } $app = new GiteaApp; $app->forceFill([ 'team_id' => $teamId, 'private_key_id' => $privateKeyId, 'name' => data_get($payload, 'name') ?: 'Imported Gitea App', 'organization' => data_get($payload, 'organization'), 'api_url' => data_get($payload, 'api_url'), 'html_url' => data_get($payload, 'html_url'), 'custom_port' => data_get($payload, 'custom_port') ?? 22, 'custom_user' => data_get($payload, 'custom_user') ?? 'git', 'is_system_wide' => false, 'is_public' => (bool) data_get($payload, 'is_public', false), 'client_id' => data_get($payload, 'client_id'), 'client_secret' => data_get($payload, 'client_secret'), 'access_token' => data_get($payload, 'access_token'), 'refresh_token' => data_get($payload, 'refresh_token'), 'expires_at' => data_get($payload, 'expires_at'), 'redirect_uri' => data_get($payload, 'redirect_uri'), 'webhook_secret' => data_get($payload, 'webhook_secret'), ]); $app->uuid = $uuid; $app->save(); return $app; } /** * @param array $payload */ private function importS3Storage(array $payload, int $teamId, bool $preserveUuids): S3Storage { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = S3Storage::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } // Reuse by endpoint+bucket+key if already present for team $byIdentity = S3Storage::query() ->where('team_id', $teamId) ->where('endpoint', data_get($payload, 'endpoint')) ->where('bucket', data_get($payload, 'bucket')) ->first(); if ($byIdentity) { return $byIdentity; } if (S3Storage::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $storage = new S3Storage; $storage->forceFill([ 'team_id' => $teamId, 'name' => data_get($payload, 'name') ?: 'Imported S3', 'description' => data_get($payload, 'description'), 'region' => data_get($payload, 'region'), 'key' => data_get($payload, 'key'), 'secret' => data_get($payload, 'secret'), 'bucket' => data_get($payload, 'bucket'), 'endpoint' => data_get($payload, 'endpoint'), 'is_usable' => (bool) data_get($payload, 'is_usable', true), ]); $storage->uuid = $uuid; $storage->save(); return $storage; } /** * @param array $payload */ private function importCloudProviderToken(array $payload, int $teamId, bool $preserveUuids): CloudProviderToken { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = CloudProviderToken::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } if (CloudProviderToken::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $token = new CloudProviderToken; $token->forceFill([ 'team_id' => $teamId, 'provider' => data_get($payload, 'provider'), 'token' => data_get($payload, 'token'), 'name' => data_get($payload, 'name') ?: 'Imported cloud token', 'description' => data_get($payload, 'description'), ]); $token->uuid = $uuid; $token->save(); return $token; } /** * A token with the same UUID in the target team is reused. A UUID that another team uses gets a new UUID. * * @param array $payload */ private function importIntegrationToken(array $payload, int $teamId, bool $preserveUuids): IntegrationToken { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); $existing = IntegrationToken::where('uuid', $uuid)->where('team_id', $teamId)->first(); if ($existing) { return $existing; } if (IntegrationToken::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $token = new IntegrationToken; $token->forceFill([ 'team_id' => $teamId, 'provider' => (string) data_get($payload, 'provider'), 'name' => data_get($payload, 'name') ?: 'Imported integration token', 'token' => (string) data_get($payload, 'token'), 'capabilities' => (array) data_get($payload, 'capabilities', []), 'metadata' => data_get($payload, 'metadata'), ]); $token->uuid = $uuid; $token->save(); return $token; } /** * The ID of the imported token, or null with a warning when the bundle names a token that it does not contain. */ private function importedIntegrationTokenId(mixed $tokenUuid, string $missingWarning): ?int { if (! is_string($tokenUuid) || $tokenUuid === '') { return null; } if (! isset($this->integrationTokenMap[$tokenUuid])) { $this->importWarnings[] = $missingWarning; return null; } return $this->integrationTokenMap[$tokenUuid]->id; } private function importSecretManagerLink(mixed $payload, Model $resource, string $label): void { if (! is_array($payload) || ! method_exists($resource, 'secretManagerLink')) { return; } $tokenId = $this->importedIntegrationTokenId( data_get($payload, 'integration_token_uuid'), "{$label}: its secret manager token was not found on this instance; link the secret manager source again.", ); if ($tokenId === null) { return; } $uuid = filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); if (SecretManagerLink::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $link = new SecretManagerLink; $link->forceFill([ 'resourceable_type' => $resource->getMorphClass(), 'resourceable_id' => $resource->getKey(), 'integration_token_id' => $tokenId, 'settings' => data_get($payload, 'settings'), ]); $link->uuid = $uuid; $link->save(); } /** * A zone of the same token and provider zone that the target team already has is reused. * * @param list> $zones */ private function importDnsZones(array $zones, bool $preserveUuids): void { foreach ($zones as $payload) { $token = $this->integrationTokenMap[(string) data_get($payload, 'integration_token_uuid')] ?? null; if (! $token) { continue; } $zone = DnsProviderZone::query() ->where('integration_token_id', $token->id) ->where('provider_zone_id', (string) data_get($payload, 'provider_zone_id')) ->first(); if (! $zone) { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); if (DnsProviderZone::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $zone = new DnsProviderZone; $zone->forceFill([ 'integration_token_id' => $token->id, 'provider_zone_id' => (string) data_get($payload, 'provider_zone_id'), 'name' => strtolower((string) data_get($payload, 'name')), 'account_id' => data_get($payload, 'account_id'), 'account_name' => data_get($payload, 'account_name'), ]); $zone->uuid = $uuid; $zone->save(); } $this->dnsZoneMap[(string) data_get($payload, 'uuid', $zone->uuid)] = $zone; } } /** * Imports the managed DNS records and links them to the imported resources. An owned record keeps the ownership * comment of the source at the provider until adoptManagedDnsRecords() replaces it. * * @param list> $records */ private function importManagedDnsRecords(array $records, Server $server, int $teamId, bool $preserveUuids): int { $count = 0; foreach ($records as $payload) { $name = (string) data_get($payload, 'name'); $zone = $this->dnsZoneMap[(string) data_get($payload, 'dns_provider_zone_uuid')] ?? null; $resources = collect(data_get($payload, 'references', [])) ->map(fn ($reference) => match (data_get($reference, 'kind')) { 'application' => $this->applicationMap[(string) data_get($reference, 'uuid')] ?? null, 'preview' => $this->previewMap[(string) data_get($reference, 'uuid')] ?? null, 'service_application' => $this->serviceApplicationMap[(string) data_get($reference, 'uuid')] ?? null, 'server' => $server, default => null, }) ->filter() ->values(); if (! $zone || $resources->isEmpty()) { $this->importWarnings[] = "DNS record {$name}: its DNS zone or resources were not imported, so this instance does not manage it."; continue; } $record = ManagedDnsRecord::query() ->where('dns_provider_zone_id', $zone->id) ->where('provider_record_id', (string) data_get($payload, 'provider_record_id')) ->first(); if (! $record) { $uuid = $preserveUuids && filled(data_get($payload, 'uuid')) ? (string) data_get($payload, 'uuid') : new_public_id(); if (ManagedDnsRecord::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $previousComment = data_get($payload, 'ownership_comment'); // Without the source comment there is no proof of ownership at the provider. $owned = (bool) data_get($payload, 'owned', false) && is_string($previousComment) && $previousComment !== ''; $record = ManagedDnsRecord::query()->create([ 'uuid' => $uuid, 'team_id' => $teamId, 'integration_token_id' => $zone->integration_token_id, 'dns_provider_zone_id' => $zone->id, 'provider_record_id' => (string) data_get($payload, 'provider_record_id'), 'type' => (string) data_get($payload, 'type'), 'name' => $name, 'content' => (string) data_get($payload, 'content'), 'owned' => $owned, ]); if ($owned && $previousComment !== $record->ownershipComment()) { $this->pendingDnsAdoptions[] = ['record_id' => $record->id, 'previous_comment' => $previousComment]; } $count++; } foreach ($resources as $resource) { $record->addReference($resource); } } return $count; } /** * Replaces the ownership comment of the source instance with the comment of this instance at the provider. * A record that cannot be adopted is no longer owned, so this instance never changes or deletes it. * * @return list warnings */ private function adoptManagedDnsRecords(): array { $warnings = []; foreach ($this->pendingDnsAdoptions as $adoption) { $record = ManagedDnsRecord::query()->find($adoption['record_id']); if (! $record) { continue; } try { $adopted = app(CloudflareDnsProvider::class)->adoptRecord($record, $adoption['previous_comment']); } catch (Throwable) { $adopted = false; } if ($adopted) { continue; } $record->forceFill(['owned' => false])->save(); $warnings[] = "DNS record {$record->name}: this instance could not take ownership; it will not change or delete it."; } $this->pendingDnsAdoptions = []; return $warnings; } /** * @param list> $previews */ private function importPreviews(array $previews, Application $application, bool $preserveUuids, bool $adoptMode, int $teamId): void { foreach ($previews as $previewPayload) { $uuid = $preserveUuids && filled(data_get($previewPayload, 'uuid')) ? (string) data_get($previewPayload, 'uuid') : new_public_id(); $preview = ApplicationPreview::withTrashed()->where('uuid', $uuid)->first(); if ($preview && ! $this->previewBelongsToTeam($preview, $teamId)) { throw ValidationException::withMessages([ 'previews' => ['An imported preview UUID cannot be used on this instance.'], ]); } if (! $preview) { $pullRequestId = data_get($previewPayload, 'pull_request_id'); if ($pullRequestId !== null) { $preview = ApplicationPreview::withTrashed() ->where('application_id', $application->id) ->where('pull_request_id', $pullRequestId) ->first(); } } if ($preview && ApplicationPreview::withTrashed()->where('uuid', $uuid)->where('id', '!=', $preview->id)->exists()) { $uuid = new_public_id(); } elseif (! $preview && ApplicationPreview::withTrashed()->where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $fqdn = data_get($previewPayload, 'fqdn'); // FQDN is globally unique; only release conflicts owned by the target team. if (filled($fqdn)) { $conflicts = ApplicationPreview::withTrashed() ->where('fqdn', $fqdn) ->when($preview, fn ($q) => $q->where('id', '!=', $preview->id)) ->get(); foreach ($conflicts as $conflict) { if (! $this->previewBelongsToTeam($conflict, $teamId)) { throw ValidationException::withMessages([ 'previews' => ['An imported preview domain conflicts with a preview outside the target team.'], ]); } } ApplicationPreview::withoutEvents(function () use ($conflicts) { $conflicts->each(function (ApplicationPreview $conflict) { $conflict->fqdn = null; $conflict->saveQuietly(); }); }); } $status = $adoptMode ? (data_get($previewPayload, 'status') ?: 'exited') : 'exited'; $attributes = [ 'application_id' => $application->id, 'pull_request_id' => data_get($previewPayload, 'pull_request_id'), 'pull_request_html_url' => data_get($previewPayload, 'pull_request_html_url') ?: '', 'pull_request_issue_comment_id' => data_get($previewPayload, 'pull_request_issue_comment_id'), 'fqdn' => $fqdn, 'status' => $status, 'git_type' => data_get($previewPayload, 'git_type'), 'docker_compose_domains' => data_get($previewPayload, 'docker_compose_domains'), 'docker_registry_image_tag' => data_get($previewPayload, 'docker_registry_image_tag'), 'domain_port_overrides' => data_get($previewPayload, 'domain_port_overrides'), 'max_restart_count' => (int) data_get($previewPayload, 'max_restart_count', 0), ]; if ($preview) { if ($preview->trashed()) { $preview->restore(); } $preview->forceFill($attributes); if ($preserveUuids && filled(data_get($previewPayload, 'uuid')) && $preview->uuid !== $uuid) { if (! ApplicationPreview::withTrashed()->where('uuid', $uuid)->where('id', '!=', $preview->id)->exists()) { $preview->uuid = $uuid; } } $preview->save(); } else { $preview = new ApplicationPreview; $preview->forceFill($attributes); $preview->uuid = $uuid; $preview->save(); } $this->previewMap[(string) data_get($previewPayload, 'uuid', $preview->uuid)] = $preview; // Avoid duplicating volumes when re-importing the same preview. if ($preview->wasRecentlyCreated || $preview->persistentStorages()->count() === 0) { $this->importPersistentStorages(data_get($previewPayload, 'persistent_storages', []), $preview); } } } private function previewBelongsToTeam(ApplicationPreview $preview, int $teamId): bool { return Application::withTrashed() ->whereKey($preview->application_id) ->whereRelation('environment.project', 'team_id', $teamId) ->exists(); } /** * @param list> $certificates */ private function importSslCertificates(array $certificates, Server $server): int { $count = 0; foreach ($certificates as $certPayload) { $resourceType = null; $resourceId = null; $kind = data_get($certPayload, 'resource_kind'); $resourceUuid = data_get($certPayload, 'resource_uuid'); if ($kind === 'application' && $resourceUuid && isset($this->applicationMap[$resourceUuid])) { $resourceType = $this->applicationMap[$resourceUuid]->getMorphClass(); $resourceId = $this->applicationMap[$resourceUuid]->id; } elseif ($kind === 'service' && $resourceUuid && isset($this->serviceMap[$resourceUuid])) { $resourceType = $this->serviceMap[$resourceUuid]->getMorphClass(); $resourceId = $this->serviceMap[$resourceUuid]->id; } elseif ($resourceUuid && isset($this->databaseMap[$resourceUuid])) { $db = $this->databaseMap[$resourceUuid]; $resourceType = $db->getMorphClass(); $resourceId = $db->id; } SslCertificate::create([ 'ssl_certificate' => data_get($certPayload, 'ssl_certificate'), 'ssl_private_key' => data_get($certPayload, 'ssl_private_key'), 'configuration_dir' => data_get($certPayload, 'configuration_dir'), 'mount_path' => data_get($certPayload, 'mount_path'), 'common_name' => data_get($certPayload, 'common_name') ?: 'imported', 'subject_alternative_names' => data_get($certPayload, 'subject_alternative_names'), 'valid_until' => data_get($certPayload, 'valid_until') ?: now()->addYear(), 'is_ca_certificate' => (bool) data_get($certPayload, 'is_ca_certificate', false), 'server_id' => $server->id, 'resource_type' => $resourceType, 'resource_id' => $resourceId, ]); $count++; } return $count; } /** * @param list> $backups */ private function importVolumeBackups(array $backups, int $teamId): int { $count = 0; foreach ($backups as $backupPayload) { $volumeUuid = (string) data_get($backupPayload, 'backupable_uuid', ''); $volume = $this->volumeMap[$volumeUuid] ?? null; if (! $volume) { continue; } $uuid = filled(data_get($backupPayload, 'uuid')) ? (string) data_get($backupPayload, 'uuid') : new_public_id(); if (ScheduledVolumeBackup::where('uuid', $uuid)->exists()) { $uuid = new_public_id(); } $s3Ids = $this->importedBackupS3StorageIds($backupPayload); $s3Id = $s3Ids[0] ?? null; $this->warnAboutMissingS3Storage($backupPayload, $s3Id, 'volume '.($volume->name ?? $volume->mount_path)); $importedBackup = ScheduledVolumeBackup::create([ 'uuid' => $uuid, 'backupable_type' => $volume->getMorphClass(), 'backupable_id' => $volume->id, 'team_id' => $teamId, 's3_storage_id' => $s3Id, 'frequency' => data_get($backupPayload, 'frequency'), 'enabled' => (bool) data_get($backupPayload, 'enabled', true), 'save_s3' => (bool) data_get($backupPayload, 'save_s3', false) && $s3Id !== null, 'disable_local_backup' => (bool) data_get($backupPayload, 'disable_local_backup', false), 'stop_during_backup' => (bool) data_get($backupPayload, 'stop_during_backup', false), 'retention_amount_locally' => data_get($backupPayload, 'retention_amount_locally'), 'retention_days_locally' => data_get($backupPayload, 'retention_days_locally'), 'retention_max_storage_locally' => data_get($backupPayload, 'retention_max_storage_locally'), 'retention_amount_s3' => data_get($backupPayload, 'retention_amount_s3'), 'retention_days_s3' => data_get($backupPayload, 'retention_days_s3'), 'retention_max_storage_s3' => data_get($backupPayload, 'retention_max_storage_s3'), 'timeout' => data_get($backupPayload, 'timeout'), 'missing_backup_notification_days' => (int) data_get($backupPayload, 'missing_backup_notification_days', 0), ]); $importedBackup->syncS3Storages($s3Ids); $count++; } return $count; } /** * @param array $destinationMap */ private function resolveDestination(?string $uuid, array $destinationMap): StandaloneDocker|SwarmDocker { if ($uuid && isset($destinationMap[$uuid])) { return $destinationMap[$uuid]; } $first = reset($destinationMap); if ($first instanceof StandaloneDocker || $first instanceof SwarmDocker) { return $first; } throw new RuntimeException('No destination available for imported resource.'); } /** * @param class-string $modelClass * @param array $attributes * @return array */ private function onlyExistingColumns(string $modelClass, array $attributes): array { /** @var Model $model */ $model = new $modelClass; $columns = Schema::getColumnListing($model->getTable()); return collect($attributes) ->only($columns) ->all(); } }