app/Models/StandaloneSqlite.php
Rama main · réplica de lectura del repositorio original.
<?php
namespace App\Models;
use App\Traits\Auditable;
use App\Traits\ClearsGlobalSearchCache;
use App\Traits\HasDatabaseHealthCheck;
use App\Traits\HasImageScans;
use App\Traits\HasLogRedactionSetting;
use App\Traits\HasMetrics;
use App\Traits\HasSafeStringAttribute;
use App\Traits\HasSecretManager;
use App\Traits\HasStars;
use App\Traits\ScopedByAccessGrants;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Collection;
use InvalidArgumentException;
class StandaloneSqlite extends BaseModel
{
use Auditable, ClearsGlobalSearchCache, HasDatabaseHealthCheck, HasFactory, HasImageScans, HasLogRedactionSetting, HasMetrics, HasSafeStringAttribute, HasSecretManager, HasStars, ScopedByAccessGrants, SoftDeletes;
public const DATA_DIRECTORY = '/var/lib/sqlite';
public const DATABASES_PATTERN = '/^[A-Za-z0-9][A-Za-z0-9._-]*(,[A-Za-z0-9][A-Za-z0-9._-]*)*$/';
protected array $auditExclude = ['last_online_at'];
protected $fillable = [
'uuid',
'name',
'description',
'sqlite_databases',
'is_log_drain_enabled',
'is_include_timestamps',
'status',
'image',
'limits_memory',
'limits_memory_swap',
'limits_memory_swappiness',
'limits_memory_reservation',
'limits_cpus',
'limits_cpuset',
'limits_cpu_shares',
'started_at',
'restart_count',
'last_restart_at',
'last_restart_type',
'last_online_at',
'custom_docker_run_options',
'destination_type',
'destination_id',
'environment_id',
'health_check_enabled',
'health_check_interval',
'health_check_timeout',
'health_check_retries',
'health_check_start_period',
];
/**
* Free-form configuration that can embed credentials. Only users who can
* update the database and `read:sensitive` tokens may read it.
*/
public const CONFIGURATION_ATTRIBUTES = [
'custom_docker_run_options',
];
/**
* Sensitive fields hidden by default in serialized output (toArray/toJson).
* API controllers should call makeVisible([...]) for callers with the
* `read:sensitive` or `root` token ability.
*/
protected $hidden = [
...self::CONFIGURATION_ATTRIBUTES,
];
protected $appends = ['database_type', 'server_status'];
protected $casts = [
'include_coolify_default_variables' => 'boolean',
'health_check_enabled' => 'boolean',
'health_check_interval' => 'integer',
'health_check_timeout' => 'integer',
'health_check_retries' => 'integer',
'health_check_start_period' => 'integer',
'restart_count' => 'integer',
'last_restart_at' => 'datetime',
'last_restart_type' => 'string',
];
protected static function booted()
{
static::created(function ($database) {
LocalPersistentVolume::create([
'name' => 'sqlite-data-'.$database->uuid,
'mount_path' => self::DATA_DIRECTORY,
'host_path' => null,
'resource_id' => $database->id,
'resource_type' => $database->getMorphClass(),
]);
});
static::forceDeleting(function ($database) {
$database->persistentStorages()->delete();
$database->scheduledBackups()->delete();
$database->environment_variables()->delete();
$database->tags()->detach();
});
static::saving(function ($database) {
if ($database->isDirty('status')) {
$database->last_online_at = now();
}
});
}
/**
* Get query builder for SQLite databases owned by current team.
* If you need all databases without further query chaining, use ownedByCurrentTeamCached() instead.
*/
public static function ownedByCurrentTeam()
{
return StandaloneSqlite::whereRelation('environment.project.team', 'id', currentTeam()->id)->orderBy('name');
}
/**
* Get all SQLite databases owned by current team (cached for request duration).
*/
public static function ownedByCurrentTeamCached()
{
return once(function () {
return StandaloneSqlite::ownedByCurrentTeam()->get();
});
}
protected function serverStatus(): Attribute
{
return Attribute::make(
get: function () {
return $this->destination->server->isFunctional();
}
);
}
public function isConfigurationChanged(bool $save = false)
{
$newConfigHash = $this->image.$this->sqlite_databases;
$newConfigHash .= $this->healthCheckConfigurationHash();
$newConfigHash .= json_encode($this->environment_variables()->get('value')->makeVisible('value')->sort());
$newConfigHash = md5($newConfigHash);
$oldConfigHash = data_get($this, 'config_hash');
if ($oldConfigHash === null) {
if ($save) {
$this->config_hash = $newConfigHash;
$this->save();
}
return true;
}
if ($oldConfigHash === $newConfigHash) {
return false;
} else {
if ($save) {
$this->config_hash = $newConfigHash;
$this->save();
}
return true;
}
}
public function isRunning()
{
return (bool) str($this->status)->contains('running');
}
public function isExited()
{
return (bool) str($this->status)->startsWith('exited');
}
public function workdir()
{
return database_configuration_dir()."/{$this->uuid}";
}
public function deleteConfigurations()
{
$server = data_get($this, 'destination.server');
$workdir = $this->workdir();
if (str($workdir)->endsWith($this->uuid)) {
instant_remote_process(['rm -rf '.$this->workdir()], $server, false);
}
}
public function deleteVolumes()
{
$persistentStorages = $this->persistentStorages()->get() ?? collect();
if ($persistentStorages->count() === 0) {
return;
}
$server = data_get($this, 'destination.server');
foreach ($persistentStorages as $storage) {
if ($storage->isSharedWithAnotherResource()) {
continue;
}
instant_remote_process(['docker volume rm -f '.escapeshellarg($storage->name)], $server, false);
}
}
public function realStatus()
{
return $this->getRawOriginal('status');
}
public function status(): Attribute
{
return Attribute::make(
set: function ($value) {
if (str($value)->contains('(')) {
$status = str($value)->before('(')->trim()->value();
$health = str($value)->after('(')->before(')')->trim()->value() ?? 'unhealthy';
} elseif (str($value)->contains(':')) {
$status = str($value)->before(':')->trim()->value();
$health = str($value)->after(':')->trim()->value() ?? 'unhealthy';
} else {
$status = $value;
$health = 'unhealthy';
}
return "$status:$health";
},
get: function ($value) {
if (str($value)->contains('(')) {
$status = str($value)->before('(')->trim()->value();
$health = str($value)->after('(')->before(')')->trim()->value() ?? 'unhealthy';
} elseif (str($value)->contains(':')) {
$status = str($value)->before(':')->trim()->value();
$health = str($value)->after(':')->trim()->value() ?? 'unhealthy';
} else {
$status = $value;
$health = 'unhealthy';
}
return "$status:$health";
},
);
}
public function tags()
{
return $this->morphToMany(Tag::class, 'taggable');
}
public function project()
{
return data_get($this, 'environment.project');
}
public function sslCertificates()
{
return $this->morphMany(SslCertificate::class, 'resource');
}
public function link()
{
if (data_get($this, 'environment.project.uuid')) {
return route('project.database.configuration', [
'project_uuid' => data_get($this, 'environment.project.uuid'),
'environment_uuid' => data_get($this, 'environment.uuid'),
'database_uuid' => data_get($this, 'uuid'),
]);
}
return null;
}
public function isLogDrainEnabled()
{
return data_get($this, 'is_log_drain_enabled', false);
}
public function team()
{
return data_get($this, 'environment.project.team');
}
public function databaseType(): Attribute
{
return new Attribute(
get: fn () => $this->type(),
);
}
public function type(): string
{
return 'standalone-sqlite';
}
/**
* The database file names configured for this database, in their configured order.
*
* @return list<string>
*/
public function databaseFiles(): array
{
return collect(explode(',', (string) $this->sqlite_databases))
->map(fn (string $file): string => trim($file))
->filter(fn (string $file): bool => $file !== '' && preg_match(self::DATABASES_PATTERN, $file) === 1)
->values()
->all();
}
/**
* The absolute path of one of this database's own files: the given file, or the first file.
*
* @throws InvalidArgumentException when the file is not one of this database's files
*/
public function databaseFilePath(?string $file = null): string
{
$files = $this->databaseFiles();
$file ??= $files[0] ?? null;
if ($file === null || ! in_array($file, $files, true)) {
throw new InvalidArgumentException('The SQLite database file is not one of the files of this database.');
}
return self::DATA_DIRECTORY.'/'.$file;
}
/**
* The file a backup is restored into by default: the file whose name appears in the
* backup file name (Coolify names backups sqlite-backup-<file>-<timestamp>.gz), else the first file.
*/
public function defaultRestoreFile(?string $backupName): ?string
{
$files = $this->databaseFiles();
$backupName = basename((string) $backupName);
$matches = array_filter($files, fn (string $file): bool => $backupName === $file
|| str_starts_with($backupName, $file.'.')
|| str_starts_with($backupName, "sqlite-backup-{$file}-"));
usort($matches, fn (string $a, string $b): int => strlen($b) <=> strlen($a));
return $matches[0] ?? $files[0] ?? null;
}
public function environment()
{
return $this->belongsTo(Environment::class);
}
public function fileStorages()
{
return $this->morphMany(LocalFileVolume::class, 'resource');
}
public function destination()
{
return $this->morphTo();
}
public function environment_variables()
{
return $this->morphMany(EnvironmentVariable::class, 'resourceable');
}
public function runtime_environment_variables()
{
return $this->morphMany(EnvironmentVariable::class, 'resourceable');
}
public function persistentStorages()
{
return $this->morphMany(LocalPersistentVolume::class, 'resource');
}
/**
* Volumes of other resources that mount this database's data volume.
*/
public function connectedVolumes()
{
return $this->hasMany(LocalPersistentVolume::class, 'standalone_sqlite_id');
}
/**
* Docker Compose applications of the same team and server that declare this database's data volume
* (or the given volume) as external. Coolify uses an external volume as written, so they mount it
* without a storage entry.
*
* @return Collection<int, Application>
*/
public function composeApplicationsUsingDataVolume(?string $volumeName = null): Collection
{
$serverId = $this->destination?->server_id;
$teamId = $this->environment?->project?->team_id;
if ($serverId === null || $teamId === null) {
return collect();
}
$volumeNames = $volumeName !== null
? collect([$volumeName])
: $this->persistentStorages()->whereNull('host_path')->pluck('name');
return Application::query()
->where('build_pack', 'dockercompose')
->whereRelation('environment.project', 'team_id', $teamId)
->with('destination')
->get()
->filter(fn (Application $application) => $application->destination?->server_id === $serverId
&& $volumeNames->intersect(composeExternalVolumeDockerNames($application->docker_compose_raw))->isNotEmpty())
->values();
}
/**
* Whether an application mounts this database's data volume.
*/
public function hasConnectedApplications(): bool
{
return $this->connectedVolumes()->exists() || $this->composeApplicationsUsingDataVolume()->isNotEmpty();
}
/**
* Names of the resources that mount this database's data volume.
*
* @return Collection<int, string>
*/
public function connectedApplicationNames(): Collection
{
return $this->connectedVolumes()->with('resource')->get()
->map(fn (LocalPersistentVolume $volume) => $volume->resource?->name)
->toBase()
->merge($this->composeApplicationsUsingDataVolume()->pluck('name'))
->filter()
->unique()
->values();
}
public function scheduledBackups()
{
return $this->morphMany(ScheduledDatabaseBackup::class, 'database');
}
public function isBackupSolutionAvailable()
{
return true;
}
}