Skip to content

An open-source, self-hostable PaaS alternative to Vercel, Heroku & Netlify that lets you easily deploy static sites, databases, full-stack applications and 360+ one-click services on your own servers.

17.2 KB
Raw Blame
<?php

namespace App\Actions\Database;

use App\Actions\Shared\EnsureContentFilesOnServer;
use App\Exceptions\DatabaseStartException;
use App\Helpers\SslHelper;
use App\Models\SslCertificate;
use App\Models\StandaloneMongodb;
use App\Traits\ExecutesDatabaseStartCommands;
use Lorisleiva\Actions\Concerns\AsAction;
use Spatie\Activitylog\Models\Activity;
use Symfony\Component\Yaml\Yaml;

class StartMongodb
{
    use AsAction, ExecutesDatabaseStartCommands;

    public StandaloneMongodb $database;

    public array $commands = [];

    public string $configuration_dir;

    private ?SslCertificate $ssl_certificate = null;

    private string $resolvedMongoUsername;

    private string $resolvedMongoPassword;

    private string $resolvedMongoDatabase;

    public function handle(StandaloneMongodb $database, ?Activity $activity = null)
    {
        $this->database = $database;

        $startCommand = 'mongod';

        $container_name = $this->database->uuid;
        $this->configuration_dir = database_configuration_dir().'/'.$container_name;

        $this->commands = [
            "echo 'Starting database.'",
            "echo 'Creating directories.'",
            "mkdir -p $this->configuration_dir",
            "echo 'Directories created successfully.'",
        ];

        if (! $this->database->enable_ssl) {
            $this->commands[] = "rm -rf $this->configuration_dir/ssl";

            $this->database->sslCertificates()->delete();

            $this->database->fileStorages()
                ->where('resource_type', $this->database->getMorphClass())
                ->where('resource_id', $this->database->id)
                ->get()
                ->filter(function ($storage) {
                    return in_array($storage->mount_path, [
                        '/etc/mongo/certs/server.pem',
                    ]);
                })
                ->each(function ($storage) {
                    $storage->delete();
                });
        } else {
            $this->commands[] = "echo 'Setting up SSL for this database.'";
            $this->commands[] = "mkdir -p $this->configuration_dir/ssl";

            $server = $this->database->destination->server;
            $caCert = $server->ensureCaCertificate() ?? throw DatabaseStartException::missingCaCertificate();
            array_push($this->commands, ...SslHelper::caCertificateFileCommands($caCert->ssl_certificate));
            $this->ssl_certificate = $this->database->sslCertificates()->first();

            if (! $this->ssl_certificate) {
                $this->commands[] = "echo 'No SSL certificate found, generating new SSL certificate for this database.'";
                $this->ssl_certificate = SslHelper::generateSslCertificate(
                    commonName: $this->database->uuid,
                    resourceType: $this->database->getMorphClass(),
                    resourceId: $this->database->id,
                    serverId: $server->id,
                    caCert: $caCert->ssl_certificate,
                    caKey: $caCert->ssl_private_key,
                    configurationDir: $this->configuration_dir,
                    mountPath: '/etc/mongo/certs',
                    isPemKeyFileRequired: true,
                );
            }
        }

        $persistent_storages = $this->generate_local_persistent_volumes();
        $persistent_file_volumes = $this->database->fileStorages()->get();
        array_push($this->commands, ...EnsureContentFilesOnServer::echoCommands($persistent_file_volumes, $this->database->destination->server));
        $volume_names = $this->generate_local_persistent_volumes_only_volume_names();
        $environment_variables = $this->generate_environment_variables();
        $this->add_custom_mongo_conf();

        $docker_compose = [
            'services' => [
                $container_name => [
                    'image' => $this->database->image,
                    'command' => $startCommand,
                    'container_name' => $container_name,
                    'environment' => $environment_variables,
                    'restart' => RESTART_MODE,
                    'networks' => [
                        $this->database->destination->network,
                    ],
                    'labels' => defaultDatabaseLabels($this->database)->toArray(),
                    'healthcheck' => $this->database->healthCheckConfiguration($this->generate_health_check_command()),
                    'mem_limit' => $this->database->limits_memory,
                    'memswap_limit' => $this->database->limits_memory_swap,
                    'mem_swappiness' => $this->database->limits_memory_swappiness,
                    'mem_reservation' => $this->database->limits_memory_reservation,
                    'cpus' => (float) $this->database->limits_cpus,
                    'cpu_shares' => $this->database->limits_cpu_shares,
                ],
            ],
            'networks' => [
                $this->database->destination->network => [
                    'external' => true,
                    'name' => $this->database->destination->network,
                    'attachable' => true,
                ],
            ],
        ];

        if (! is_null($this->database->limits_cpuset)) {
            data_set($docker_compose, "services.{$container_name}.cpuset", $this->database->limits_cpuset);
        }

        if ($this->database->destination->server->isLogDrainEnabled() && $this->database->isLogDrainEnabled()) {
            $docker_compose['services'][$container_name]['logging'] = generate_log_drain_configuration($this->database->destination->server);
        }

        if (count($this->database->ports_mappings_array) > 0) {
            $docker_compose['services'][$container_name]['ports'] = $this->database->ports_mappings_array;
        }

        $docker_compose['services'][$container_name]['volumes'] ??= [];

        if (count($persistent_storages) > 0) {
            $docker_compose['services'][$container_name]['volumes'] = array_merge(
                $docker_compose['services'][$container_name]['volumes'] ?? [],
                $persistent_storages
            );
        }

        if (count($persistent_file_volumes) > 0) {
            $docker_compose['services'][$container_name]['volumes'] = array_merge(
                $docker_compose['services'][$container_name]['volumes'] ?? [],
                $persistent_file_volumes->map(function ($item) {
                    return "$item->fs_path:$item->mount_path";
                })->toArray()
            );
        }

        if (count($volume_names) > 0) {
            $docker_compose['volumes'] = $volume_names;
        }

        if (! empty($this->database->mongo_conf)) {
            $docker_compose['services'][$container_name]['volumes'] = array_merge(
                $docker_compose['services'][$container_name]['volumes'] ?? [],
                [[
                    'type' => 'bind',
                    'source' => $this->configuration_dir.'/mongod.conf',
                    'target' => '/etc/mongo/mongod.conf',
                    'read_only' => true,
                ]]
            );
            $docker_compose['services'][$container_name]['command'] = ['mongod', '--config', '/etc/mongo/mongod.conf'];
        }

        $this->add_default_database();

        $docker_compose['services'][$container_name]['volumes'] = array_merge(
            $docker_compose['services'][$container_name]['volumes'] ?? [],
            [[
                'type' => 'bind',
                'source' => $this->configuration_dir.'/docker-entrypoint-initdb.d',
                'target' => '/docker-entrypoint-initdb.d',
                'read_only' => true,
            ]]
        );

        if ($this->database->enable_ssl) {
            $docker_compose['services'][$container_name]['volumes'] = array_merge(
                $docker_compose['services'][$container_name]['volumes'] ?? [],
                [
                    [
                        'type' => 'bind',
                        'source' => '/data/coolify/ssl/coolify-ca.crt',
                        'target' => '/etc/mongo/certs/ca.pem',
                        'read_only' => true,
                    ],
                ]
            );
        }

        // Add custom docker run options
        $docker_run_options = convertDockerRunToCompose($this->database->custom_docker_run_options);
        $docker_compose = generateCustomDockerRunOptionsForDatabases($docker_run_options, $docker_compose, $container_name, $this->database->destination->network);

        if ($this->database->enable_ssl) {
            $commandParts = ['mongod'];

            if (! empty($this->database->mongo_conf)) {
                $commandParts = ['mongod', '--config', '/etc/mongo/mongod.conf'];
            }

            $sslConfig = match ($this->database->ssl_mode) {
                'allow' => [
                    '--tlsMode=allowTLS',
                    '--tlsAllowConnectionsWithoutCertificates',
                    '--tlsAllowInvalidHostnames',
                ],
                'prefer' => [
                    '--tlsMode=preferTLS',
                    '--tlsAllowConnectionsWithoutCertificates',
                    '--tlsAllowInvalidHostnames',
                ],
                'require' => [
                    '--tlsMode=requireTLS',
                    '--tlsAllowConnectionsWithoutCertificates',
                    '--tlsAllowInvalidHostnames',
                ],
                'verify-full' => [
                    '--tlsMode=requireTLS',
                    '--tlsAllowInvalidHostnames',
                ],
                default => [],
            };

            $commandParts = [...$commandParts, ...$sslConfig];
            $commandParts[] = '--tlsCAFile';
            $commandParts[] = '/etc/mongo/certs/ca.pem';
            $commandParts[] = '--tlsCertificateKeyFile';
            $commandParts[] = '/etc/mongo/certs/server.pem';

            $docker_compose['services'][$container_name]['command'] = $commandParts;
        }

        if (! $this->database->isHealthcheckEnabled()) {
            unset($docker_compose['services'][$container_name]['healthcheck']);
        }
        $docker_compose = Yaml::dump($docker_compose, 10);
        $docker_compose_base64 = base64_encode($docker_compose);
        $this->commands[] = "echo '{$docker_compose_base64}' | base64 -d | tee $this->configuration_dir/docker-compose.yml > /dev/null";
        $readme = generate_readme_file($this->database->name, now());
        $this->commands[] = "echo '{$readme}' | tee $this->configuration_dir/README.md > /dev/null";
        $this->commands[] = 'echo '.escapeshellarg("Pulling {$database->image} image.");
        $this->commands[] = serverDockerConfigPrefix($this->database->destination->server)."docker compose -f $this->configuration_dir/docker-compose.yml pull";
        if ($this->database->enable_ssl) {
            $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml run --rm --no-deps --user root --entrypoint chown $container_name mongodb:mongodb /etc/mongo/certs/server.pem < /dev/null";
        }
        $this->commands[] = dockerStopCommand(10, $container_name, $this->database->destination->server).' 2>/dev/null || true';
        $this->commands[] = "docker rm -f $container_name 2>/dev/null || true";
        $this->commands[] = "docker compose -f $this->configuration_dir/docker-compose.yml up -d";
        $this->commands[] = "echo 'Database started.'";

        return $this->executeDatabaseStartCommands($this->commands, $database, $activity);
    }

    private function generate_local_persistent_volumes()
    {
        $local_persistent_volumes = [];
        foreach ($this->database->persistentStorages as $persistentStorage) {
            if ($persistentStorage->host_path !== '' && $persistentStorage->host_path !== null) {
                $local_persistent_volumes[] = $persistentStorage->host_path.':'.$persistentStorage->mount_path;
            } else {
                $volume_name = $persistentStorage->name;
                $local_persistent_volumes[] = $volume_name.':'.$persistentStorage->mount_path;
            }
        }

        return $local_persistent_volumes;
    }

    private function generate_local_persistent_volumes_only_volume_names()
    {
        $local_persistent_volumes_names = [];
        foreach ($this->database->persistentStorages as $persistentStorage) {
            if ($persistentStorage->host_path) {
                continue;
            }
            $name = $persistentStorage->name;
            $local_persistent_volumes_names[$name] = [
                'name' => $name,
                'external' => false,
            ];
        }

        return $local_persistent_volumes_names;
    }

    private function generate_environment_variables()
    {
        $environment_variables = collect();
        $this->resolvedMongoUsername = (string) $this->database->mongo_initdb_root_username;
        $this->resolvedMongoPassword = (string) $this->database->mongo_initdb_root_password;
        $this->resolvedMongoDatabase = (string) $this->database->mongo_initdb_database;
        foreach ($this->database->runtime_environment_variables as $env) {
            $rawValue = (string) $this->database->resolveSecretManagerEnvironmentVariableValue($env);
            $resolvedValue = (string) $this->database->formatEnvironmentVariableValue($env, $rawValue);
            $environment_variables->push($env->key.'='.$resolvedValue);
            if ($env->key === 'MONGO_INITDB_ROOT_USERNAME') {
                $this->resolvedMongoUsername = $rawValue;
            } elseif ($env->key === 'MONGO_INITDB_ROOT_PASSWORD') {
                $this->resolvedMongoPassword = $rawValue;
            } elseif ($env->key === 'MONGO_INITDB_DATABASE') {
                $this->resolvedMongoDatabase = $rawValue;
            }
        }

        if (! $this->hasEnvironmentVariable($environment_variables, 'MONGO_INITDB_ROOT_USERNAME')) {
            $environment_variables->push("MONGO_INITDB_ROOT_USERNAME={$this->database->mongo_initdb_root_username}");
        }

        if (! $this->hasEnvironmentVariable($environment_variables, 'MONGO_INITDB_ROOT_PASSWORD')) {
            $environment_variables->push("MONGO_INITDB_ROOT_PASSWORD={$this->database->mongo_initdb_root_password}");
        }

        if (! $this->hasEnvironmentVariable($environment_variables, 'MONGO_INITDB_DATABASE')) {
            $environment_variables->push("MONGO_INITDB_DATABASE={$this->database->mongo_initdb_database}");
        }

        $this->addCoolifyEnvironmentVariables($environment_variables);

        return $environment_variables->all();
    }

    /**
     * The shell is chosen when the check runs: images before MongoDB 5 (and some custom images) have only the legacy mongo shell.
     * The check uses ping, which needs no authentication and passes on members that are not the writable primary (e.g. an uninitiated replica set).
     */
    private function generate_health_check_command(): array
    {
        $mongosh = $this->health_check_shell_command(legacy: false);
        $mongo = $this->health_check_shell_command(legacy: true);

        return ['CMD-SHELL', "if command -v mongosh >/dev/null 2>&1; then {$mongosh}; else {$mongo}; fi"];
    }

    private function health_check_shell_command(bool $legacy): string
    {
        $command = [$legacy ? 'mongo' : 'mongosh', '--quiet', '--host', $this->database->uuid];

        if ($this->database->enable_ssl) {
            $command = [...$command, $legacy ? '--ssl' : '--tls', $legacy ? '--sslCAFile' : '--tlsCAFile', '/etc/mongo/certs/ca.pem'];

            if ($this->database->ssl_mode === 'verify-full') {
                $command = [...$command, $legacy ? '--sslPEMKeyFile' : '--tlsCertificateKeyFile', '/etc/mongo/certs/server.pem'];
            }
        }

        $command = [
            ...$command,
            '--eval',
            'quit(db.adminCommand({ ping: 1 }).ok === 1 ? 0 : 1)',
        ];

        return implode(' ', array_map('escapeshellarg', $command));
    }

    private function add_custom_mongo_conf()
    {
        if (is_null($this->database->mongo_conf) || empty($this->database->mongo_conf)) {
            return;
        }
        $filename = 'mongod.conf';
        $content = $this->database->mongo_conf;
        $content_base64 = base64_encode($content);
        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/{$filename} > /dev/null";
        // The container user must read the read-only mount; a strict server umask leaves the file unreadable.
        $this->commands[] = "chmod 644 $this->configuration_dir/{$filename}";
    }

    private function add_default_database()
    {
        $dbJson = json_encode($this->resolvedMongoDatabase, JSON_UNESCAPED_SLASHES);
        $userJson = json_encode($this->resolvedMongoUsername, JSON_UNESCAPED_SLASHES);
        $pwdJson = json_encode($this->resolvedMongoPassword, JSON_UNESCAPED_SLASHES);
        $content = "db = db.getSiblingDB({$dbJson});db.createCollection('init_collection');db.createUser({user: {$userJson}, pwd: {$pwdJson}, roles: [{role:\"readWrite\",db:{$dbJson}}]});";
        $content_base64 = base64_encode($content);
        $this->commands[] = "mkdir -p $this->configuration_dir/docker-entrypoint-initdb.d";
        $this->commands[] = "echo '{$content_base64}' | base64 -d | tee $this->configuration_dir/docker-entrypoint-initdb.d/01-default-database.js > /dev/null";
    }
}