lasthourcloud/app/Models/Server.php

856 lines
31 KiB
PHP
Raw Normal View History

<?php
namespace App\Models;
use App\Actions\Server\InstallDocker;
2023-09-21 15:48:31 +00:00
use App\Enums\ProxyTypes;
use App\Notifications\Server\Revived;
use App\Notifications\Server\Unreachable;
2023-05-03 05:23:45 +00:00
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
2023-05-03 05:23:45 +00:00
use Spatie\SchemalessAttributes\Casts\SchemalessAttributes;
2023-06-20 18:19:31 +00:00
use Spatie\SchemalessAttributes\SchemalessAttributesTrait;
use Illuminate\Support\Str;
use Illuminate\Support\Stringable;
2024-03-11 16:17:34 +00:00
use Spatie\Url\Url;
use Symfony\Component\Yaml\Yaml;
2023-05-03 05:23:45 +00:00
class Server extends BaseModel
{
2023-06-20 18:19:31 +00:00
use SchemalessAttributesTrait;
2023-11-22 14:18:49 +00:00
public static $batch_counter = 0;
2023-08-23 08:14:39 +00:00
protected static function booted()
{
2023-10-09 09:00:18 +00:00
static::saving(function ($server) {
2023-10-09 18:12:03 +00:00
$payload = [];
if ($server->user) {
$payload['user'] = Str::of($server->user)->trim();
}
if ($server->ip) {
$payload['ip'] = Str::of($server->ip)->trim();
}
$server->forceFill($payload);
});
2023-08-23 08:14:39 +00:00
static::created(function ($server) {
ServerSetting::create([
'server_id' => $server->id,
]);
});
static::deleting(function ($server) {
2023-08-29 13:51:30 +00:00
$server->destinations()->each(function ($destination) {
$destination->delete();
});
2023-08-23 08:14:39 +00:00
$server->settings()->delete();
});
}
public $casts = [
'proxy' => SchemalessAttributes::class,
'logdrain_axiom_api_key' => 'encrypted',
'logdrain_newrelic_license_key' => 'encrypted',
];
2023-06-20 18:19:31 +00:00
protected $schemalessAttributes = [
'proxy',
];
2023-08-23 08:14:39 +00:00
protected $guarded = [];
static public function isReachable()
{
return Server::ownedByCurrentTeam()->whereRelation('settings', 'is_reachable', true);
}
static public function ownedByCurrentTeam(array $select = ['*'])
{
2023-08-22 15:44:49 +00:00
$teamId = currentTeam()->id;
$selectArray = collect($select)->concat(['id']);
2023-12-04 14:08:24 +00:00
return Server::whereTeamId($teamId)->with('settings', 'swarmDockers', 'standaloneDockers')->select($selectArray->all())->orderBy('name');
}
static public function isUsable()
{
return Server::ownedByCurrentTeam()->whereRelation('settings', 'is_reachable', true)->whereRelation('settings', 'is_usable', true)->whereRelation('settings', 'is_swarm_worker', false)->whereRelation('settings', 'is_build_server', false)->whereRelation('settings', 'force_disabled', false);
}
static public function destinationsByServer(string $server_id)
{
$server = Server::ownedByCurrentTeam()->get()->where('id', $server_id)->firstOrFail();
$standaloneDocker = collect($server->standaloneDockers->all());
$swarmDocker = collect($server->swarmDockers->all());
return $standaloneDocker->concat($swarmDocker);
}
public function settings()
{
return $this->hasOne(ServerSetting::class);
}
2023-12-04 14:08:24 +00:00
public function addInitialNetwork()
{
2023-11-28 14:49:24 +00:00
if ($this->id === 0) {
if ($this->isSwarm()) {
SwarmDocker::create([
'id' => 0,
'name' => 'coolify',
'network' => 'coolify-overlay',
'server_id' => $this->id,
]);
} else {
StandaloneDocker::create([
'id' => 0,
'name' => 'coolify',
'network' => 'coolify',
'server_id' => $this->id,
]);
}
} else {
if ($this->isSwarm()) {
SwarmDocker::create([
2023-11-28 17:31:04 +00:00
'name' => 'coolify-overlay',
2023-11-28 14:49:24 +00:00
'network' => 'coolify-overlay',
'server_id' => $this->id,
]);
} else {
StandaloneDocker::create([
'name' => 'coolify',
2023-11-28 14:49:24 +00:00
'network' => 'coolify',
'server_id' => $this->id,
]);
}
}
}
2024-03-12 09:42:56 +00:00
public function setupDefault404Redirect()
{
$dynamic_conf_path = $this->proxyPath() . "/dynamic";
$proxy_type = $this->proxyType();
$redirect_url = $this->proxy->redirect_url;
if ($proxy_type === 'TRAEFIK_V2') {
$default_redirect_file = "$dynamic_conf_path/default_redirect_404.yaml";
} else if ($proxy_type === 'CADDY') {
$default_redirect_file = "$dynamic_conf_path/default_redirect_404.caddy";
}
if (empty($redirect_url)) {
if ($proxy_type === 'CADDY') {
$conf = ":80, :443 {
respond 404
}";
$conf =
"# This file is automatically generated by Coolify.\n" .
"# Do not edit it manually (only if you know what are you doing).\n\n" .
$conf;
$base64 = base64_encode($conf);
instant_remote_process([
"mkdir -p $dynamic_conf_path",
"echo '$base64' | base64 -d > $default_redirect_file",
], $this);
$this->reloadCaddy();
return;
}
2024-03-12 09:42:56 +00:00
instant_remote_process([
"mkdir -p $dynamic_conf_path",
"rm -f $default_redirect_file",
], $this);
return;
}
if ($proxy_type === 'TRAEFIK_V2') {
$dynamic_conf = [
'http' =>
[
'routers' =>
[
'catchall' =>
[
'entryPoints' => [
0 => 'http',
1 => 'https',
],
'service' => 'noop',
'rule' => "HostRegexp(`{catchall:.*}`)",
'priority' => 1,
'middlewares' => [
0 => 'redirect-regexp@file',
],
],
],
'services' =>
[
'noop' =>
[
'loadBalancer' =>
[
'servers' =>
[
0 =>
[
'url' => '',
],
],
],
],
],
'middlewares' =>
[
'redirect-regexp' =>
[
'redirectRegex' =>
[
'regex' => '(.*)',
'replacement' => $redirect_url,
'permanent' => false,
],
],
],
],
];
$conf = Yaml::dump($dynamic_conf, 12, 2);
$conf =
"# This file is automatically generated by Coolify.\n" .
"# Do not edit it manually (only if you know what are you doing).\n\n" .
$conf;
$base64 = base64_encode($conf);
} else if ($proxy_type === 'CADDY') {
$conf = ":80, :443 {
redir $redirect_url
}";
$conf =
"# This file is automatically generated by Coolify.\n" .
"# Do not edit it manually (only if you know what are you doing).\n\n" .
$conf;
$base64 = base64_encode($conf);
}
instant_remote_process([
"mkdir -p $dynamic_conf_path",
"echo '$base64' | base64 -d > $default_redirect_file",
], $this);
if (config('app.env') == 'local') {
ray($conf);
}
if ($proxy_type === 'CADDY') {
$this->reloadCaddy();
}
}
2024-03-11 16:17:34 +00:00
public function setupDynamicProxyConfiguration()
{
$settings = InstanceSettings::get();
$dynamic_config_path = $this->proxyPath() . "/dynamic";
2024-03-12 11:30:40 +00:00
if ($this->proxyType() === 'TRAEFIK_V2') {
$file = "$dynamic_config_path/coolify.yaml";
if (empty($settings->fqdn)) {
instant_remote_process([
"rm -f $file",
], $this);
} else {
$url = Url::fromString($settings->fqdn);
$host = $url->getHost();
$schema = $url->getScheme();
$traefik_dynamic_conf = [
'http' =>
[
'middlewares' => [
'redirect-to-https' => [
'redirectscheme' => [
'scheme' => 'https',
],
],
'gzip' => [
'compress' => true,
],
],
'routers' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'coolify-http' =>
[
'middlewares' => [
0 => 'gzip',
2024-03-11 16:17:34 +00:00
],
2024-03-12 11:30:40 +00:00
'entryPoints' => [
0 => 'http',
2024-03-11 16:17:34 +00:00
],
2024-03-12 11:30:40 +00:00
'service' => 'coolify',
'rule' => "Host(`{$host}`)",
2024-03-11 16:17:34 +00:00
],
2024-03-12 11:30:40 +00:00
'coolify-realtime-ws' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'entryPoints' => [
0 => 'http',
2024-03-11 16:17:34 +00:00
],
2024-03-12 11:30:40 +00:00
'service' => 'coolify-realtime',
'rule' => "Host(`{$host}`) && PathPrefix(`/app`)",
2024-03-11 16:17:34 +00:00
],
2024-03-12 11:30:40 +00:00
],
'services' =>
[
'coolify' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'loadBalancer' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'servers' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
0 =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'url' => 'http://coolify:80',
2024-03-11 16:17:34 +00:00
],
],
],
2024-03-12 11:30:40 +00:00
],
'coolify-realtime' =>
[
'loadBalancer' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'servers' =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
0 =>
2024-03-11 16:17:34 +00:00
[
2024-03-12 11:30:40 +00:00
'url' => 'http://coolify-realtime:6001',
2024-03-11 16:17:34 +00:00
],
],
],
],
],
2024-03-12 11:30:40 +00:00
],
];
2024-03-11 16:17:34 +00:00
2024-03-12 11:30:40 +00:00
if ($schema === 'https') {
$traefik_dynamic_conf['http']['routers']['coolify-http']['middlewares'] = [
0 => 'redirect-to-https',
];
2024-03-11 16:17:34 +00:00
2024-03-12 11:30:40 +00:00
$traefik_dynamic_conf['http']['routers']['coolify-https'] = [
'entryPoints' => [
0 => 'https',
],
'service' => 'coolify',
'rule' => "Host(`{$host}`)",
'tls' => [
'certresolver' => 'letsencrypt',
],
];
$traefik_dynamic_conf['http']['routers']['coolify-realtime-wss'] = [
'entryPoints' => [
0 => 'https',
],
'service' => 'coolify-realtime',
'rule' => "Host(`{$host}`) && PathPrefix(`/app`)",
'tls' => [
'certresolver' => 'letsencrypt',
],
];
}
$yaml = Yaml::dump($traefik_dynamic_conf, 12, 2);
$yaml =
"# This file is automatically generated by Coolify.\n" .
"# Do not edit it manually (only if you know what are you doing).\n\n" .
$yaml;
2024-03-11 16:17:34 +00:00
2024-03-12 11:30:40 +00:00
$base64 = base64_encode($yaml);
instant_remote_process([
"mkdir -p $dynamic_config_path",
"echo '$base64' | base64 -d > $file",
], $this);
2024-03-11 16:17:34 +00:00
2024-03-12 11:30:40 +00:00
if (config('app.env') == 'local') {
// ray($yaml);
2024-03-11 16:17:34 +00:00
}
2024-03-12 11:30:40 +00:00
}
} else if ($this->proxyType() === 'CADDY') {
$file = "$dynamic_config_path/coolify.caddy";
if (empty($settings->fqdn)) {
instant_remote_process([
"rm -f $file",
], $this);
$this->reloadCaddy();
} else {
$url = Url::fromString($settings->fqdn);
$host = $url->getHost();
$schema = $url->getScheme();
$caddy_file = "
2024-03-11 16:17:34 +00:00
$schema://$host {
handle /app/* {
reverse_proxy coolify-realtime:6001
}
2024-03-11 16:17:34 +00:00
reverse_proxy coolify:80
}";
2024-03-12 11:30:40 +00:00
$base64 = base64_encode($caddy_file);
instant_remote_process([
"echo '$base64' | base64 -d > $file",
], $this);
$this->reloadCaddy();
2024-03-11 16:17:34 +00:00
}
}
}
2024-03-12 09:42:56 +00:00
public function reloadCaddy()
{
2024-03-11 16:31:28 +00:00
return instant_remote_process([
2024-03-12 09:42:56 +00:00
"docker exec coolify-proxy caddy reload --config /config/caddy/Caddyfile.autosave",
2024-03-11 16:31:28 +00:00
], $this);
}
2024-03-11 16:17:34 +00:00
public function proxyPath()
{
2024-03-11 14:08:05 +00:00
$base_path = config('coolify.base_config_path');
$proxyType = $this->proxyType();
$proxy_path = "$base_path/proxy";
// TODO: should use /traefik for already exisiting configurations?
// Should move everything except /caddy and /nginx to /traefik
// The code needs to be modified as well, so maybe it does not worth it
2024-03-11 14:08:05 +00:00
if ($proxyType === ProxyTypes::TRAEFIK_V2->value) {
$proxy_path = $proxy_path;
} else if ($proxyType === ProxyTypes::CADDY->value) {
$proxy_path = $proxy_path . '/caddy';
} else if ($proxyType === ProxyTypes::NGINX->value) {
$proxy_path = $proxy_path . '/nginx';
}
return $proxy_path;
}
2023-09-25 07:17:42 +00:00
public function proxyType()
{
2024-03-12 11:30:40 +00:00
// $proxyType = $this->proxy->get('type');
// if ($proxyType === ProxyTypes::NONE->value) {
// return $proxyType;
// }
2024-03-11 14:08:05 +00:00
// if (is_null($proxyType)) {
// $this->proxy->type = ProxyTypes::TRAEFIK_V2->value;
// $this->proxy->status = ProxyStatus::EXITED->value;
// $this->save();
// }
return data_get($this->proxy, 'type');
2023-09-20 13:42:41 +00:00
}
2023-06-20 18:19:31 +00:00
public function scopeWithProxy(): Builder
2023-05-30 13:52:17 +00:00
{
2023-06-20 18:19:31 +00:00
return $this->proxy->modelScope();
2023-05-30 13:52:17 +00:00
}
public function isLocalhost()
{
return $this->ip === 'host.docker.internal' || $this->id === 0;
}
2024-01-17 10:52:56 +00:00
static public function buildServers($teamId)
{
return Server::whereTeamId($teamId)->whereRelation('settings', 'is_reachable', true)->whereRelation('settings', 'is_build_server', true);
}
public function skipServer()
{
if ($this->ip === '1.2.3.4') {
2024-02-26 13:22:24 +00:00
// ray('skipping 1.2.3.4');
return true;
}
if ($this->settings->force_disabled === true) {
2024-02-26 13:22:24 +00:00
// ray('force_disabled');
return true;
}
return false;
}
public function isForceDisabled()
{
return $this->settings->force_disabled;
}
public function forceEnableServer()
{
$this->settings->update([
'force_disabled' => false,
]);
}
public function forceDisableServer()
{
2024-02-25 22:34:01 +00:00
$this->settings->update([
'force_disabled' => true,
2024-02-25 22:34:01 +00:00
]);
$sshKeyFileLocation = "id.root@{$this->uuid}";
Storage::disk('ssh-keys')->delete($sshKeyFileLocation);
Storage::disk('ssh-mux')->delete($this->muxFilename());
2024-02-25 22:34:01 +00:00
}
2023-12-19 14:36:59 +00:00
public function isServerReady(int $tries = 3)
{
2023-12-20 10:21:17 +00:00
if ($this->skipServer()) {
return false;
}
2023-12-21 08:57:39 +00:00
$serverUptimeCheckNumber = $this->unreachable_count;
2023-12-20 10:21:17 +00:00
if ($this->unreachable_count < $tries) {
$serverUptimeCheckNumber = $this->unreachable_count + 1;
}
2023-12-21 09:00:41 +00:00
if ($this->unreachable_count > $tries) {
$serverUptimeCheckNumber = $tries;
}
2023-12-21 08:57:39 +00:00
2023-12-19 14:36:59 +00:00
$serverUptimeCheckNumberMax = $tries;
2023-12-21 09:28:02 +00:00
// ray('server: ' . $this->name);
// ray('serverUptimeCheckNumber: ' . $serverUptimeCheckNumber);
// ray('serverUptimeCheckNumberMax: ' . $serverUptimeCheckNumberMax);
2023-12-19 14:16:08 +00:00
$result = $this->validateConnection();
if ($result) {
if ($this->unreachable_notification_sent === true) {
$this->update(['unreachable_notification_sent' => false]);
}
return true;
} else {
if ($serverUptimeCheckNumber >= $serverUptimeCheckNumberMax) {
2023-12-19 14:16:08 +00:00
// Reached max number of retries
if ($this->unreachable_notification_sent === false) {
ray('Server unreachable, sending notification...');
2023-12-13 11:01:27 +00:00
$this->team?->notify(new Unreachable($this));
$this->update(['unreachable_notification_sent' => true]);
}
2023-12-19 14:16:08 +00:00
if ($this->settings->is_reachable === true) {
$this->settings()->update([
'is_reachable' => false,
]);
}
foreach ($this->applications() as $application) {
$application->update(['status' => 'exited']);
}
foreach ($this->databases() as $database) {
$database->update(['status' => 'exited']);
}
2024-01-17 14:48:01 +00:00
foreach ($this->services()->get() as $service) {
$apps = $service->applications()->get();
$dbs = $service->databases()->get();
foreach ($apps as $app) {
$app->update(['status' => 'exited']);
}
foreach ($dbs as $db) {
$db->update(['status' => 'exited']);
}
}
2023-12-19 14:16:08 +00:00
} else {
$this->update([
2023-12-19 14:16:08 +00:00
'unreachable_count' => $this->unreachable_count + 1,
]);
}
2023-12-19 14:16:08 +00:00
return false;
}
}
public function getDiskUsage()
{
return instant_remote_process(["df /| tail -1 | awk '{ print $5}' | sed 's/%//g'"], $this, false);
}
public function definedResources()
{
$applications = $this->applications();
$databases = $this->databases();
$services = $this->services();
return $applications->concat($databases)->concat($services->get());
}
2024-02-19 12:28:14 +00:00
public function stopUnmanaged($id)
{
return instant_remote_process(["docker stop -t 0 $id"], $this);
}
2024-02-19 12:28:14 +00:00
public function restartUnmanaged($id)
{
return instant_remote_process(["docker restart $id"], $this);
}
2024-02-19 12:28:14 +00:00
public function startUnmanaged($id)
{
return instant_remote_process(["docker start $id"], $this);
}
public function loadUnmanagedContainers()
{
if ($this->isFunctional()) {
$containers = instant_remote_process(["docker ps -a --format '{{json .}}' "], $this);
$containers = format_docker_command_output_to_json($containers);
$containers = $containers->map(function ($container) {
$labels = data_get($container, 'Labels');
if (!str($labels)->contains("coolify.managed")) {
return $container;
}
return null;
});
$containers = $containers->filter();
return collect($containers);
} else {
return collect([]);
}
}
2023-11-06 17:04:18 +00:00
public function hasDefinedResources()
2023-06-15 13:15:27 +00:00
{
$applications = $this->applications()->count() > 0;
$databases = $this->databases()->count() > 0;
$services = $this->services()->count() > 0;
2023-11-06 17:04:18 +00:00
if ($applications || $databases || $services) {
2023-06-15 13:15:27 +00:00
return true;
}
return false;
}
2023-09-11 20:29:34 +00:00
public function databases()
{
2023-08-29 13:51:30 +00:00
return $this->destinations()->map(function ($standaloneDocker) {
2023-10-24 12:31:28 +00:00
$postgresqls = data_get($standaloneDocker, 'postgresqls', collect([]));
$redis = data_get($standaloneDocker, 'redis', collect([]));
$mongodbs = data_get($standaloneDocker, 'mongodbs', collect([]));
$mysqls = data_get($standaloneDocker, 'mysqls', collect([]));
$mariadbs = data_get($standaloneDocker, 'mariadbs', collect([]));
return $postgresqls->concat($redis)->concat($mongodbs)->concat($mysqls)->concat($mariadbs);
})->filter(function ($item) {
2024-02-19 12:28:14 +00:00
return data_get($item, 'name') !== 'coolify-db';
2023-08-29 13:51:30 +00:00
})->flatten();
}
2023-06-15 13:15:27 +00:00
public function applications()
{
$applications = $this->destinations()->map(function ($standaloneDocker) {
2023-06-15 13:15:27 +00:00
return $standaloneDocker->applications;
})->flatten();
$additionalApplicationIds = DB::table('additional_destinations')->where('server_id', $this->id)->get('application_id');
$additionalApplicationIds = collect($additionalApplicationIds)->map(function ($item) {
return $item->application_id;
});
Application::whereIn('id', $additionalApplicationIds)->get()->each(function ($application) use ($applications) {
$applications->push($application);
});
return $applications;
2023-06-15 13:15:27 +00:00
}
public function dockerComposeBasedApplications()
{
return $this->applications()->filter(function ($application) {
return data_get($application, 'build_pack') === 'dockercompose';
});
}
public function dockerComposeBasedPreviewDeployments()
{
return $this->previews()->filter(function ($preview) {
$applicationId = data_get($preview, 'application_id');
$application = Application::find($applicationId);
if (!$application) {
return false;
}
return data_get($application, 'build_pack') === 'dockercompose';
});
}
2023-09-25 07:17:42 +00:00
public function services()
{
2023-09-21 15:48:31 +00:00
return $this->hasMany(Service::class);
}
public function getIp(): Attribute
{
return Attribute::make(
get: function () {
if (isDev()) {
return '127.0.0.1';
}
if ($this->isLocalhost()) {
return base_ip();
}
return $this->ip;
}
);
}
2023-09-25 07:17:42 +00:00
public function previews()
{
2023-09-14 13:52:04 +00:00
return $this->destinations()->map(function ($standaloneDocker) {
return $standaloneDocker->applications->map(function ($application) {
return $application->previews;
})->flatten();
})->flatten();
}
2023-06-13 08:02:58 +00:00
public function destinations()
{
$standalone_docker = $this->hasMany(StandaloneDocker::class)->get();
$swarm_docker = $this->hasMany(SwarmDocker::class)->get();
// $additional_dockers = $this->belongsToMany(StandaloneDocker::class, 'additional_destinations')->withPivot('server_id')->get();
// return $standalone_docker->concat($swarm_docker)->concat($additional_dockers);
return $standalone_docker->concat($swarm_docker);
2023-06-13 08:02:58 +00:00
}
2023-05-02 10:47:52 +00:00
public function standaloneDockers()
2023-04-25 12:43:35 +00:00
{
2023-05-02 10:47:52 +00:00
return $this->hasMany(StandaloneDocker::class);
}
2023-05-04 13:45:53 +00:00
2023-05-02 10:47:52 +00:00
public function swarmDockers()
{
return $this->hasMany(SwarmDocker::class);
2023-04-25 12:43:35 +00:00
}
2023-05-04 13:45:53 +00:00
2023-03-27 12:31:42 +00:00
public function privateKey()
{
2023-03-27 12:31:42 +00:00
return $this->belongsTo(PrivateKey::class);
}
2023-05-03 05:23:45 +00:00
2023-06-16 11:13:09 +00:00
public function muxFilename()
{
return "{$this->ip}_{$this->port}_{$this->user}";
}
2023-07-07 19:35:29 +00:00
public function team()
{
return $this->belongsTo(Team::class);
}
2023-09-11 20:29:34 +00:00
public function isProxyShouldRun()
{
if ($this->proxyType() === ProxyTypes::NONE->value || $this->settings->is_build_server) {
2023-09-25 07:17:42 +00:00
return false;
}
return true;
2023-09-11 20:29:34 +00:00
}
2023-09-25 07:17:42 +00:00
public function isFunctional()
{
return $this->settings->is_reachable && $this->settings->is_usable && !$this->settings->force_disabled;
2023-09-12 11:14:01 +00:00
}
public function isLogDrainEnabled()
{
2023-12-01 10:13:58 +00:00
return $this->settings->is_logdrain_newrelic_enabled || $this->settings->is_logdrain_highlight_enabled || $this->settings->is_logdrain_axiom_enabled || $this->settings->is_logdrain_custom_enabled;
}
public function validateOS(): bool | Stringable
{
$os_release = instant_remote_process(['cat /etc/os-release'], $this);
2024-01-08 20:59:26 +00:00
$releaseLines = collect(explode("\n", $os_release));
$collectedData = collect([]);
2024-01-08 20:59:26 +00:00
foreach ($releaseLines as $line) {
$item = Str::of($line)->trim();
$collectedData->put($item->before('=')->value(), $item->after('=')->lower()->replace('"', '')->value());
}
$ID = data_get($collectedData, 'ID');
// $ID_LIKE = data_get($collectedData, 'ID_LIKE');
// $VERSION_ID = data_get($collectedData, 'VERSION_ID');
$supported = collect(SUPPORTED_OS)->filter(function ($supportedOs) use ($ID) {
if (str($supportedOs)->contains($ID)) {
return str($ID);
}
});
if ($supported->count() === 1) {
2024-02-22 10:28:45 +00:00
// ray('supported');
2023-11-28 12:17:59 +00:00
return str($supported->first());
} else {
2024-02-22 10:28:45 +00:00
// ray('not supported');
return false;
}
}
2023-11-28 14:49:24 +00:00
public function isSwarm()
{
2023-11-29 09:06:52 +00:00
return data_get($this, 'settings.is_swarm_manager') || data_get($this, 'settings.is_swarm_worker');
2023-11-28 14:49:24 +00:00
}
2023-12-18 13:01:25 +00:00
public function isSwarmManager()
{
return data_get($this, 'settings.is_swarm_manager');
}
public function isSwarmWorker()
{
return data_get($this, 'settings.is_swarm_worker');
}
2023-10-09 09:00:18 +00:00
public function validateConnection()
{
config()->set('coolify.mux_enabled', false);
2023-11-28 14:49:24 +00:00
$server = Server::find($this->id);
2023-12-19 11:24:43 +00:00
if (!$server) {
return false;
}
2023-12-04 19:47:32 +00:00
if ($server->skipServer()) {
return false;
}
// EC2 does not have `uptime` command, lol
2024-02-15 12:52:42 +00:00
$uptime = instant_remote_process(['ls /'], $server, false);
2023-10-09 09:00:18 +00:00
if (!$uptime) {
2023-12-04 19:47:32 +00:00
$server->settings()->update([
'is_reachable' => false,
]);
2023-10-09 09:00:18 +00:00
return false;
} else {
2023-12-04 19:47:32 +00:00
$server->settings()->update([
'is_reachable' => true,
]);
2023-11-28 14:49:24 +00:00
$server->update([
'unreachable_count' => 0,
]);
2023-10-09 09:00:18 +00:00
}
2023-12-04 19:47:32 +00:00
if (data_get($server, 'unreachable_notification_sent') === true) {
2023-12-13 11:01:27 +00:00
$server->team?->notify(new Revived($server));
2023-11-28 14:49:24 +00:00
$server->update(['unreachable_notification_sent' => false]);
}
2023-10-09 09:00:18 +00:00
return true;
}
public function installDocker()
{
$activity = InstallDocker::run($this);
return $activity;
}
2023-10-09 09:00:18 +00:00
public function validateDockerEngine($throwError = false)
{
$dockerBinary = instant_remote_process(["command -v docker"], $this, false);
if (is_null($dockerBinary)) {
$this->settings->is_usable = false;
$this->settings->save();
if ($throwError) {
throw new \Exception('Server is not usable. Docker Engine is not installed.');
2023-10-09 09:00:18 +00:00
}
return false;
}
2024-02-22 10:28:45 +00:00
try {
2024-02-22 13:46:11 +00:00
instant_remote_process(["docker version"], $this);
2024-02-22 10:28:45 +00:00
} catch (\Throwable $e) {
$this->settings->is_usable = false;
$this->settings->save();
if ($throwError) {
throw new \Exception('Server is not usable. Docker Engine is not running.');
}
return false;
}
2023-10-09 09:00:18 +00:00
$this->settings->is_usable = true;
$this->settings->save();
$this->validateCoolifyNetwork(isSwarm: false, isBuildServer: $this->settings->is_build_server);
2023-11-28 14:49:24 +00:00
return true;
}
public function validateDockerCompose($throwError = false)
{
$dockerCompose = instant_remote_process(["docker compose version"], $this, false);
if (is_null($dockerCompose)) {
$this->settings->is_usable = false;
$this->settings->save();
if ($throwError) {
throw new \Exception('Server is not usable. Docker Compose is not installed.');
}
return false;
}
$this->settings->is_usable = true;
$this->settings->save();
return true;
}
2023-11-28 14:49:24 +00:00
public function validateDockerSwarm()
{
$swarmStatus = instant_remote_process(["docker info|grep -i swarm"], $this, false);
$swarmStatus = str($swarmStatus)->trim()->after(':')->trim();
if ($swarmStatus === 'inactive') {
throw new \Exception('Docker Swarm is not initiated. Please join the server to a swarm before continuing.');
return false;
}
$this->settings->is_usable = true;
$this->settings->save();
$this->validateCoolifyNetwork(isSwarm: true);
2023-10-09 09:00:18 +00:00
return true;
}
public function validateDockerEngineVersion()
{
$dockerVersion = instant_remote_process(["docker version|head -2|grep -i version| awk '{print $2}'"], $this, false);
$dockerVersion = checkMinimumDockerEngineVersion($dockerVersion);
if (is_null($dockerVersion)) {
$this->settings->is_usable = false;
$this->settings->save();
return false;
}
$this->settings->is_reachable = true;
2023-10-09 09:00:18 +00:00
$this->settings->is_usable = true;
$this->settings->save();
return true;
}
public function validateCoolifyNetwork($isSwarm = false, $isBuildServer = false)
2023-10-24 12:31:28 +00:00
{
if ($isBuildServer) {
return;
}
2023-11-28 14:49:24 +00:00
if ($isSwarm) {
2023-11-28 17:31:04 +00:00
return instant_remote_process(["docker network create --attachable --driver overlay coolify-overlay >/dev/null 2>&1 || true"], $this, false);
2023-11-28 14:49:24 +00:00
} else {
return instant_remote_process(["docker network create coolify --attachable >/dev/null 2>&1 || true"], $this, false);
}
2023-10-09 09:00:18 +00:00
}
2023-07-14 11:38:24 +00:00
}