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.

fix(databases): reserve start and restart atomically

Andras Bacsaifbfe342f89ea
diff --git a/app/Actions/Database/RestartDatabase.php b/app/Actions/Database/RestartDatabase.php
index 3bb83e4187..3e8f6dec83 100644
--- a/app/Actions/Database/RestartDatabase.php
+++ b/app/Actions/Database/RestartDatabase.php
@@ -10,28 +10,44 @@ use App\Models\StandaloneMongodb;
use App\Models\StandaloneMysql;
use App\Models\StandalonePostgresql;
use App\Models\StandaloneRedis;
+use App\Support\DatabaseOperationReservation;
+use App\Support\ResourceStartActivity;
use Lorisleiva\Actions\Concerns\AsAction;
class RestartDatabase
{
use AsAction;
- public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database)
+ /**
+ * @param string|null $reservation The token from StartDatabase::reserveOperation(). The request
+ * that queued this action holds the reservation; this action
+ * keeps it during the stop and releases it after the start.
+ */
+ public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, ?string $reservation = null)
{
- $server = $database->destination->server;
- if (! $server->isFunctional()) {
- return 'Server is not functional';
+ $reservation ??= DatabaseOperationReservation::acquire($database->uuid);
+ if ($reservation === null) {
+ return ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE;
}
- $busyError = StartDatabase::operationInProgressError($database);
- if ($busyError !== null) {
- return $busyError;
- }
- $prerequisiteError = StartDatabase::prerequisiteError($database);
- if ($prerequisiteError !== null) {
- return $prerequisiteError;
- }
- StopDatabase::run($database, dockerCleanup: false);
- return StartDatabase::run($database);
+ try {
+ $server = $database->destination->server;
+ if (! $server->isFunctional()) {
+ return 'Server is not functional';
+ }
+ $busyError = StartDatabase::operationInProgressError($database, $reservation);
+ if ($busyError !== null) {
+ return $busyError;
+ }
+ $prerequisiteError = StartDatabase::prerequisiteError($database);
+ if ($prerequisiteError !== null) {
+ return $prerequisiteError;
+ }
+ StopDatabase::run($database, dockerCleanup: false);
+
+ return StartDatabase::run($database, $reservation);
+ } finally {
+ DatabaseOperationReservation::release($database->uuid, $reservation);
+ }
}
}
diff --git a/app/Actions/Database/StartDatabase.php b/app/Actions/Database/StartDatabase.php
index 6bc06969d2..5e75d8d0b5 100644
--- a/app/Actions/Database/StartDatabase.php
+++ b/app/Actions/Database/StartDatabase.php
@@ -14,6 +14,7 @@ use App\Models\StandaloneMongodb;
use App\Models\StandaloneMysql;
use App\Models\StandalonePostgresql;
use App\Models\StandaloneRedis;
+use App\Support\DatabaseOperationReservation;
use App\Support\ResourceStartActivity;
use Lorisleiva\Actions\Concerns\AsAction;
use Lorisleiva\Actions\Decorators\JobDecorator;
@@ -29,13 +30,31 @@ class StartDatabase
$job->onQueue(deployment_queue());
}
- public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database): Activity|string
+ /**
+ * @param string|null $reservation The token from reserveOperation(). The request that queued
+ * this action holds the reservation; this action releases it.
+ */
+ public function handle(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, ?string $reservation = null): Activity|string
+ {
+ $reservation ??= DatabaseOperationReservation::acquire($database->uuid);
+ if ($reservation === null) {
+ return ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE;
+ }
+
+ try {
+ return $this->queueStart($database, $reservation);
+ } finally {
+ DatabaseOperationReservation::release($database->uuid, $reservation);
+ }
+ }
+
+ private function queueStart(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, string $reservation): Activity|string
{
$server = $database->destination->server;
if (! $server->isFunctional()) {
return 'Server is not functional';
}
- $busyError = self::operationInProgressError($database);
+ $busyError = self::operationInProgressError($database, $reservation);
if ($busyError !== null) {
return $busyError;
}
@@ -87,17 +106,64 @@ class StartDatabase
return $activity;
}
+ /**
+ * Reserve a start or restart before it is queued, so that a parallel request cannot also
+ * queue one before the queued action has created its activity. Pass the token to the
+ * queued action, which releases the reservation.
+ *
+ * @return string|null The reservation token, or null when another operation is in progress.
+ */
+ public static function reserveOperation(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database): ?string
+ {
+ $reservation = DatabaseOperationReservation::acquire($database->uuid);
+ if ($reservation === null) {
+ return null;
+ }
+
+ if (self::operationInProgressError($database, $reservation) !== null) {
+ DatabaseOperationReservation::release($database->uuid, $reservation);
+
+ return null;
+ }
+
+ return $reservation;
+ }
+
+ /**
+ * Queue a start or restart action with a reservation. Release the reservation if the
+ * action cannot be queued, because then no action will release it.
+ *
+ * @param class-string<StartDatabase|RestartDatabase> $action
+ */
+ public static function dispatchReserved(string $action, StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, string $reservation): void
+ {
+ try {
+ $action::dispatch($database, $reservation);
+ } catch (Throwable $e) {
+ DatabaseOperationReservation::release($database->uuid, $reservation);
+
+ throw $e;
+ }
+ }
+
/**
* Refuse a second start/restart while a start, restart or import of this database is
- * queued or running. The UI hides Start/Restart in this state; this is the server-side check.
- * Stale start activities do not block and are marked as failed, so the UI stays consistent.
+ * reserved, queued or running. The UI hides Start/Restart in this state; this is the
+ * server-side check. Stale start activities do not block and are marked as failed, so
+ * the UI stays consistent.
+ *
+ * @param string|null $reservation The token of the caller's own reservation, which does not block.
*/
- public static function operationInProgressError(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database): ?string
+ public static function operationInProgressError(StandaloneRedis|StandalonePostgresql|StandaloneMongodb|StandaloneMysql|StandaloneMariadb|StandaloneKeydb|StandaloneDragonfly|StandaloneClickhouse $database, ?string $reservation = null): ?string
{
if (blank($database->uuid)) {
return null;
}
+ if (DatabaseOperationReservation::isHeldByOther($database->uuid, $reservation)) {
+ return ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE;
+ }
+
$liveOperations = collect([
ResourceStartActivity::DATABASE_START_OPERATION,
ResourceStartActivity::DATABASE_IMPORT_OPERATION,
diff --git a/app/Actions/Database/StartDatabaseImport.php b/app/Actions/Database/StartDatabaseImport.php
index aea98b0045..7439e9f1b0 100644
--- a/app/Actions/Database/StartDatabaseImport.php
+++ b/app/Actions/Database/StartDatabaseImport.php
@@ -10,6 +10,7 @@ use App\Support\DatabaseBackupFileValidator;
use App\Support\DatabaseImport\DatabaseImportCommandBuilder;
use App\Support\DatabaseImport\DatabaseImportException;
use App\Support\DatabaseImport\DatabaseImportSource;
+use App\Support\DatabaseOperationReservation;
use App\Support\ResourceStartActivity;
use App\Support\ValidationPatterns;
use Illuminate\Database\Eloquent\Model;
@@ -59,9 +60,19 @@ class StartDatabaseImport
throw new DatabaseImportException('A database import is already running.', 409);
}
+ // A start or restart can be queued without an activity yet: its reservation blocks the import.
+ // The import holds the reservation until its own activity exists.
+ $reservation = null;
+
try {
+ $reservation = DatabaseOperationReservation::acquire($resource->uuid);
+ if ($reservation === null) {
+ throw new DatabaseImportException(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE, 409);
+ }
+
return $this->startImport($resource, $source, $teamId, $server, $container, $network);
} finally {
+ DatabaseOperationReservation::release($resource->uuid, $reservation);
$lock->release();
}
}
@@ -72,6 +83,10 @@ class StartDatabaseImport
if (ResourceStartActivity::failStale($active)->isNotEmpty()) {
throw new DatabaseImportException('A database import is already running.', 409);
}
+ $activeStarts = ResourceStartActivity::active($resource->uuid, ResourceStartActivity::DATABASE_START_OPERATION, $teamId);
+ if (ResourceStartActivity::failStale($activeStarts)->isNotEmpty()) {
+ throw new DatabaseImportException(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE, 409);
+ }
$operation = (string) Str::uuid();
$containerPath = "/tmp/restore_{$operation}";
diff --git a/app/Http/Controllers/Api/DatabasesController.php b/app/Http/Controllers/Api/DatabasesController.php
index 2189a3e08c..7b04422384 100644
--- a/app/Http/Controllers/Api/DatabasesController.php
+++ b/app/Http/Controllers/Api/DatabasesController.php
@@ -22,6 +22,7 @@ use App\Models\Server;
use App\Models\StandaloneDocker;
use App\Models\StandalonePostgresql;
use App\Models\SwarmDocker;
+use App\Support\ResourceStartActivity;
use App\Support\ValidationPatterns;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\JsonResponse;
@@ -3264,10 +3265,11 @@ class DatabasesController extends Controller
if (str($database->status)->contains('running')) {
return response()->json(['message' => 'Database is already running.'], 400);
}
- if ($busyError = StartDatabase::operationInProgressError($database)) {
- return response()->json(['message' => $busyError], 409);
+ $reservation = StartDatabase::reserveOperation($database);
+ if ($reservation === null) {
+ return response()->json(['message' => ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE], 409);
}
- StartDatabase::dispatch($database);
+ StartDatabase::dispatchReserved(StartDatabase::class, $database, $reservation);
auditLog('api.database.started', [
'team_id' => $teamId,
@@ -3454,10 +3456,11 @@ class DatabasesController extends Controller
$this->authorize('manage', $database);
- if ($busyError = StartDatabase::operationInProgressError($database)) {
- return response()->json(['message' => $busyError], 409);
+ $reservation = StartDatabase::reserveOperation($database);
+ if ($reservation === null) {
+ return response()->json(['message' => ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE], 409);
}
- RestartDatabase::dispatch($database);
+ StartDatabase::dispatchReserved(RestartDatabase::class, $database, $reservation);
auditLog('api.database.restarted', [
'team_id' => $teamId,
diff --git a/app/Http/Controllers/Api/DeployController.php b/app/Http/Controllers/Api/DeployController.php
index a0f0cc1aed..c9029de94a 100644
--- a/app/Http/Controllers/Api/DeployController.php
+++ b/app/Http/Controllers/Api/DeployController.php
@@ -12,6 +12,7 @@ use App\Models\ApplicationPreview;
use App\Models\Server;
use App\Models\Service;
use App\Models\Tag;
+use App\Support\ResourceStartActivity;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Http\Request;
use OpenApi\Attributes as OA;
@@ -582,7 +583,12 @@ class DeployController extends Controller
} catch (AuthorizationException $e) {
return ['message' => 'Unauthorized to start this database.', 'deployment_uuid' => null];
}
- StartDatabase::dispatch($resource);
+ $reservation = StartDatabase::reserveOperation($resource);
+ if ($reservation === null) {
+ $message = ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE;
+ break;
+ }
+ StartDatabase::dispatchReserved(StartDatabase::class, $resource, $reservation);
$resource->started_at ??= now();
$resource->save();
diff --git a/app/Mcp/Tools/Control.php b/app/Mcp/Tools/Control.php
index 4b52d3d93f..aca6b46564 100644
--- a/app/Mcp/Tools/Control.php
+++ b/app/Mcp/Tools/Control.php
@@ -13,6 +13,7 @@ use App\Mcp\Concerns\BuildsResponse;
use App\Mcp\Concerns\ResolvesResource;
use App\Mcp\Concerns\ResolvesTeam;
use App\Models\Application;
+use App\Support\ResourceStartActivity;
use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Mcp\Request;
use Laravel\Mcp\Response;
@@ -140,13 +141,18 @@ class Control extends Tool
return ['message' => 'Database is already running.'];
}
+ $reservation = StartDatabase::reserveOperation($database);
+ if ($reservation === null) {
+ throw new \RuntimeException(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+ }
+
if ($action === 'restart') {
- RestartDatabase::dispatch($database);
+ StartDatabase::dispatchReserved(RestartDatabase::class, $database, $reservation);
return ['message' => 'Database restart request queued.'];
}
- StartDatabase::dispatch($database);
+ StartDatabase::dispatchReserved(StartDatabase::class, $database, $reservation);
return ['message' => 'Database starting request queued.'];
}
diff --git a/app/Support/DatabaseOperationReservation.php b/app/Support/DatabaseOperationReservation.php
new file mode 100644
index 0000000000..936f5ab56f
--- /dev/null
+++ b/app/Support/DatabaseOperationReservation.php
@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Support;
+
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Str;
+
+/**
+ * Reserves a database for one start, restart or import between the request and the moment
+ * the operation has created its activity.
+ *
+ * The API and MCP queue StartDatabase/RestartDatabase, and the queued action creates the
+ * activity later. Without a reservation, two parallel requests both find no activity and
+ * both get "queued". Cache::add() is atomic (SET NX on Redis), so only one request can
+ * hold the reservation. The holder releases it when its activity exists or when it stops.
+ * The TTL releases the reservation of a lost job; it is the same as the limit after which
+ * a queued start activity is stale.
+ */
+class DatabaseOperationReservation
+{
+ public const TTL_SECONDS = ResourceStartActivity::QUEUED_STALE_AFTER_SECONDS;
+
+ public static function key(string $databaseUuid): string
+ {
+ return "database-operation-pending:{$databaseUuid}";
+ }
+
+ /**
+ * A database without a UUID (not saved) has nothing to reserve: the token is returned
+ * without a cache entry, the same as operationInProgressError() does not block it.
+ *
+ * @return string|null The reservation token, or null when another operation holds the reservation.
+ */
+ public static function acquire(?string $databaseUuid): ?string
+ {
+ $token = (string) Str::uuid();
+ if (blank($databaseUuid)) {
+ return $token;
+ }
+
+ return Cache::add(self::key($databaseUuid), $token, self::TTL_SECONDS) ? $token : null;
+ }
+
+ /**
+ * True when a reservation exists that does not belong to the given token.
+ */
+ public static function isHeldByOther(?string $databaseUuid, ?string $token = null): bool
+ {
+ if (blank($databaseUuid)) {
+ return false;
+ }
+
+ $holder = Cache::get(self::key($databaseUuid));
+
+ return $holder !== null && $holder !== $token;
+ }
+
+ /**
+ * Release the reservation only if the token still holds it, so that an expired
+ * reservation does not remove the reservation of a newer request.
+ */
+ public static function release(?string $databaseUuid, ?string $token): void
+ {
+ if ($token === null || blank($databaseUuid)) {
+ return;
+ }
+
+ if (Cache::get(self::key($databaseUuid)) === $token) {
+ Cache::forget(self::key($databaseUuid));
+ }
+ }
+}
diff --git a/tests/Feature/DatabaseStartConcurrencyTest.php b/tests/Feature/DatabaseStartConcurrencyTest.php
index 3645368e30..8f51caccd5 100644
--- a/tests/Feature/DatabaseStartConcurrencyTest.php
+++ b/tests/Feature/DatabaseStartConcurrencyTest.php
@@ -17,14 +17,17 @@ use App\Models\StandaloneDocker;
use App\Models\StandalonePostgresql;
use App\Models\Team;
use App\Models\User;
+use App\Support\DatabaseOperationReservation;
use App\Support\ResourceStartActivity;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Bus;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Queue;
+use Illuminate\Support\Once;
use Illuminate\Support\Str;
use Livewire\Livewire;
+use Lorisleiva\Actions\Decorators\JobDecorator;
use Spatie\Activitylog\Models\Activity;
uses(RefreshDatabase::class);
@@ -207,6 +210,293 @@ describe('start and restart guards', function () {
});
});
+/**
+ * Run the queued StartDatabase/RestartDatabase action that the API pushed to the fake queue,
+ * with the same parameters (including the reservation token) that the worker would use.
+ */
+function runPushedDatabaseAction(string $actionClass): mixed
+{
+ $job = Queue::pushed(JobDecorator::class, fn (JobDecorator $job) => $job->getAction() instanceof $actionClass)->last();
+ expect($job)->not->toBeNull();
+
+ return $job->handle();
+}
+
+function databaseOperationReserved(string $databaseUuid): bool
+{
+ return Cache::has(DatabaseOperationReservation::key($databaseUuid));
+}
+
+describe('pending operation reservation', function () {
+ it('rejects a second API start while the first start is still in the queue', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk()
+ ->assertJson(['message' => 'Database starting request queued.']);
+
+ // The queued action did not run yet, so no activity exists. The reservation must block.
+ expect(databaseStartActivityCount($this->database->uuid))->toBe(0);
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertStatus(409)
+ ->assertJson(['message' => ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE]);
+
+ StartDatabase::assertPushed(1);
+ });
+
+ it('rejects an API restart while an API start is still in the queue', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/restart")
+ ->assertStatus(409)
+ ->assertJson(['message' => ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE]);
+
+ RestartDatabase::assertNotPushed();
+ });
+
+ it('rejects a second API restart and an API start while the first restart is still in the queue', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/restart")
+ ->assertOk()
+ ->assertJson(['message' => 'Database restarting request queued.']);
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/restart")
+ ->assertStatus(409)
+ ->assertJson(['message' => ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE]);
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertStatus(409);
+
+ RestartDatabase::assertPushed(1);
+ StartDatabase::assertNotPushed();
+ });
+
+ it('hands the reservation over to the start activity and allows a new start after it finished', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+ expect(databaseOperationReserved($this->database->uuid))->toBeTrue();
+
+ $activity = runPushedDatabaseAction(StartDatabase::class);
+
+ expect($activity)->toBeInstanceOf(Activity::class)
+ ->and(databaseOperationReserved($this->database->uuid))->toBeFalse();
+ Queue::assertPushed(DatabaseStartJob::class, 1);
+
+ // The queued start activity now blocks.
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertStatus(409);
+
+ $activity->properties = $activity->properties->merge(['status' => ProcessStatus::FINISHED->value]);
+ $activity->save();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+ });
+
+ it('stops and starts in the queued restart action and then releases the reservation', function () {
+ Queue::fake();
+ StopDatabase::shouldRun()->once();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/restart")
+ ->assertOk();
+
+ $activity = runPushedDatabaseAction(RestartDatabase::class);
+
+ expect($activity)->toBeInstanceOf(Activity::class)
+ ->and(databaseOperationReserved($this->database->uuid))->toBeFalse()
+ ->and(databaseStartActivityCount($this->database->uuid))->toBe(1);
+ });
+
+ it('releases the reservation when the queued action does not start the database', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ // For example a start that another path created without a reservation.
+ concurrentStartActivity($this->database->uuid, $this->team->id);
+
+ expect(runPushedDatabaseAction(StartDatabase::class))->toBe(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE)
+ ->and(databaseOperationReserved($this->database->uuid))->toBeFalse();
+ Queue::assertNotPushed(DatabaseStartJob::class);
+ });
+
+ it('lets a new start through after a lost reservation expires', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ $this->travel(DatabaseOperationReservation::TTL_SECONDS - 1)->seconds();
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertStatus(409);
+
+ $this->travel(2)->seconds();
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ StartDatabase::assertPushed(2);
+ });
+
+ it('does not let an expired reservation start after a newer request took the reservation', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+ $firstJob = Queue::pushed(JobDecorator::class)->first();
+
+ $this->travel(DatabaseOperationReservation::TTL_SECONDS + 1)->seconds();
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ expect($firstJob->handle())->toBe(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE)
+ ->and(databaseOperationReserved($this->database->uuid))->toBeTrue()
+ ->and(databaseStartActivityCount($this->database->uuid))->toBe(0);
+ });
+
+ it('does not start from the UI while an API start is still in the queue', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ Livewire::actingAs($this->user)->test(Heading::class, ['database' => $this->database])
+ ->call('start')
+ ->assertDispatched('error', ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+
+ Queue::assertNotPushed(DatabaseStartJob::class);
+ expect(databaseStartActivityCount($this->database->uuid))->toBe(0);
+ });
+
+ it('does not stop the database on a UI restart while an API restart is still in the queue', function () {
+ Queue::fake();
+ StopDatabase::shouldRun()->never();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/restart")
+ ->assertOk();
+
+ Livewire::actingAs($this->user)->test(Heading::class, ['database' => $this->database])
+ ->call('restart')
+ ->assertDispatched('error', ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+ });
+
+ it('releases its own reservation after a UI start created the activity', function () {
+ Bus::fake();
+
+ Livewire::actingAs($this->user)->test(Heading::class, ['database' => $this->database])
+ ->call('start')
+ ->assertNotDispatched('error');
+
+ Bus::assertDispatched(DatabaseStartJob::class);
+ expect(databaseOperationReserved($this->database->uuid))->toBeFalse()
+ ->and(databaseStartActivityCount($this->database->uuid))->toBe(1);
+ });
+
+ it('rejects an API start while a UI start holds the reservation', function () {
+ Queue::fake();
+ $token = DatabaseOperationReservation::acquire($this->database->uuid);
+ expect($token)->toBeString();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertStatus(409);
+
+ DatabaseOperationReservation::release($this->database->uuid, $token);
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+ });
+
+ it('does not release a reservation that another request holds', function () {
+ $token = DatabaseOperationReservation::acquire($this->database->uuid);
+
+ DatabaseOperationReservation::release($this->database->uuid, 'another-token');
+
+ expect(databaseOperationReserved($this->database->uuid))->toBeTrue()
+ ->and(DatabaseOperationReservation::acquire($this->database->uuid))->toBeNull();
+ DatabaseOperationReservation::release($this->database->uuid, $token);
+ expect(databaseOperationReserved($this->database->uuid))->toBeFalse();
+ });
+
+ it('does not queue a database start through the deploy API while a start is still in the queue', function () {
+ Queue::fake();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson('/api/v1/deploy', ['uuid' => $this->database->uuid])
+ ->assertOk()
+ ->assertJsonPath('deployments.0.message', ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+
+ StartDatabase::assertPushed(1);
+ });
+
+ it('does not queue a database start through the MCP control tool while a start is still in the queue', function (string $action) {
+ Queue::fake();
+ InstanceSettings::query()->whereKey(0)->update(['is_mcp_server_enabled' => true]);
+ $this->team->update(['is_mcp_server_enabled' => true]);
+ Once::flush();
+ $mcpToken = $this->user->createToken('mcp-deploy', ['read', 'deploy'])->plainTextToken;
+
+ $this->withHeaders(databaseStartApiHeaders($this->bearerToken))
+ ->postJson("/api/v1/databases/{$this->database->uuid}/start")
+ ->assertOk();
+
+ $response = $this->withHeaders([
+ 'Content-Type' => 'application/json',
+ 'Accept' => 'application/json, text/event-stream',
+ 'Authorization' => 'Bearer '.$mcpToken,
+ ])->postJson('/mcp', [
+ 'jsonrpc' => '2.0',
+ 'id' => 1,
+ 'method' => 'tools/call',
+ 'params' => [
+ 'name' => 'control',
+ 'arguments' => (object) [
+ 'resource' => 'database',
+ 'action' => $action,
+ 'uuid' => $this->database->uuid,
+ ],
+ ],
+ ]);
+
+ $response->assertOk();
+ expect($response->json('result.isError'))->toBeTrue()
+ ->and($response->json('result.content.0.text'))->toContain(ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+ StartDatabase::assertPushed(1);
+ RestartDatabase::assertNotPushed();
+ })->with(['start', 'restart']);
+});
+
describe('start job', function () {
beforeEach(function () {
Event::fake([DatabaseStatusChanged::class]);
diff --git a/tests/Feature/StartDatabaseImportConcurrencyTest.php b/tests/Feature/StartDatabaseImportConcurrencyTest.php
index bab4f99b83..e238c2ae95 100644
--- a/tests/Feature/StartDatabaseImportConcurrencyTest.php
+++ b/tests/Feature/StartDatabaseImportConcurrencyTest.php
@@ -11,6 +11,7 @@ use App\Models\StandalonePostgresql;
use App\Models\Team;
use App\Support\DatabaseImport\DatabaseImportException;
use App\Support\DatabaseImport\DatabaseImportSource;
+use App\Support\DatabaseOperationReservation;
use App\Support\ResourceStartActivity;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Cache;
@@ -191,3 +192,53 @@ test('an import interrupted by a Coolify restart is failed at boot and no longer
expect(fn () => startImport($this->database, $this->team->id))
->toThrow(DatabaseImportException::class, 'The server path is invalid.');
});
+
+test('an import is rejected while a start or restart of the database waits in the queue', function () {
+ $token = DatabaseOperationReservation::acquire($this->database->uuid);
+
+ try {
+ expect(fn () => startImport($this->database, $this->team->id))
+ ->toThrow(DatabaseImportException::class, ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+ } finally {
+ DatabaseOperationReservation::release($this->database->uuid, $token);
+ }
+});
+
+test('the 409 status is used when a pending start blocks an import', function () {
+ $token = DatabaseOperationReservation::acquire($this->database->uuid);
+
+ try {
+ startImport($this->database, $this->team->id);
+ $this->fail('The import was not rejected.');
+ } catch (DatabaseImportException $exception) {
+ expect($exception->status)->toBe(409);
+ } finally {
+ DatabaseOperationReservation::release($this->database->uuid, $token);
+ }
+});
+
+test('an import is rejected while a start of the database is running', function (ProcessStatus $status) {
+ Activity::create([
+ 'log_name' => 'default',
+ 'description' => '[]',
+ 'properties' => [
+ 'team_id' => $this->team->id,
+ 'type_uuid' => $this->database->uuid,
+ 'operation' => ResourceStartActivity::DATABASE_START_OPERATION,
+ 'status' => $status->value,
+ ],
+ ]);
+
+ expect(fn () => startImport($this->database, $this->team->id))
+ ->toThrow(DatabaseImportException::class, ResourceStartActivity::DATABASE_OPERATION_IN_PROGRESS_MESSAGE);
+})->with([
+ 'queued' => ProcessStatus::QUEUED,
+ 'in progress' => ProcessStatus::IN_PROGRESS,
+]);
+
+test('an import holds the operation reservation and releases it afterwards', function () {
+ expect(fn () => startImport($this->database, $this->team->id))
+ ->toThrow(DatabaseImportException::class, 'The server path is invalid.');
+
+ expect(Cache::has(DatabaseOperationReservation::key($this->database->uuid)))->toBeFalse();
+});