rosslh/coolify
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: correct Sentinel default health status and remove debug logging

Browse source 
This commit addresses container status reporting issues and removes debug logging:

**Primary Fix:**
- Changed PushServerUpdateJob to default to 'unknown' instead of 'unhealthy' when health_status field is missing from Sentinel data
- This ensures containers WITHOUT healthcheck defined are correctly reported as "unknown" not "unhealthy"
- Matches SSH path behavior (GetContainersStatus) which already defaulted to 'unknown'

**Service Multi-Container Aggregation:**
- Implemented service container status aggregation (same pattern as applications)
- Added serviceContainerStatuses collection to both Sentinel and SSH paths
- Services now aggregate status using priority: unhealthy > unknown > healthy
- Prevents race conditions where last-processed container would win

**Debug Logging Cleanup:**
- Removed all [STATUS-DEBUG] logging statements (25 total)
- Removed all ray() debugging calls (3 total)
- Removed proof_unknown_preserved and health_status_was_null debug fields
- Code is now production-ready

**Test Coverage:**
- Added 2 new tests for Sentinel default health status behavior
- Added 5 new tests for service aggregation in SSH path
- All 16 tests pass (66 assertions)

**Note:** The root cause was identified as Sentinel (Go binary) also defaulting to "unhealthy". That will need a separate fix in the Sentinel codebase.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Andras Bacsai 2025-11-20 11:10:34 +01:00
parent 747a48b933
commit 14bba8ba86
4 changed files with 447 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

200
app/Actions/Docker/GetContainersStatus.php
View file

@ -11,7 +11,6 @@
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Lorisleiva\Actions\Concerns\AsAction;
class GetContainersStatus
@ -32,6 +31,8 @@ class GetContainersStatus
protected ?Collection $applicationContainerRestartCounts;
protected ?Collection $serviceContainerStatuses;
public function handle(Server $server, ?Collection $containers = null, ?Collection $containerReplicates = null)
{
$this->containers = $containers;
@ -230,31 +231,22 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
continue;
}
// Check if this container is excluded from health checks
// Store container status for aggregation
if (! isset($this->serviceContainerStatuses)) {
$this->serviceContainerStatuses = collect();
}
$key = $serviceLabelId.':'.$subType.':'.$subId;
if (! $this->serviceContainerStatuses->has($key)) {
$this->serviceContainerStatuses->put($key, collect());
}
$containerName = data_get($labels, 'com.docker.compose.service');
$isExcluded = false;
if ($containerName) {
$dockerComposeRaw = data_get($parentService, 'docker_compose_raw');
if ($dockerComposeRaw) {
try {
$dockerCompose = \Symfony\Component\Yaml\Yaml::parse($dockerComposeRaw);
$serviceConfig = data_get($dockerCompose, "services.{$containerName}", []);
$excludeFromHc = data_get($serviceConfig, 'exclude_from_hc', false);
$restartPolicy = data_get($serviceConfig, 'restart', 'always');
if ($excludeFromHc || $restartPolicy === 'no') {
$isExcluded = true;
}
} catch (\Exception $e) {
// If we can't parse, treat as not excluded
}
}
}
// Append :excluded suffix if container is excluded
if ($isExcluded) {
$containerStatus = str_replace(')', ':excluded)', $containerStatus);
$this->serviceContainerStatuses->get($key)->put($containerName, $containerStatus);
}
// Mark service as found
if ($subType === 'application') {
$service = $parentService->applications()->where('id', $subId)->first();
} else {
@ -262,12 +254,6 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
}
if ($service) {
$foundServices[] = "$service->id-$service->name";
$statusFromDb = $service->status;
if ($statusFromDb !== $containerStatus) {
$service->update(['status' => $containerStatus]);
} else {
$service->update(['last_online_at' => now()]);
}
}
}
}
@ -343,26 +329,9 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
if ($recentlyRestarted) {
// Keep it as degraded if it was recently in a crash loop
Log::debug('[STATUS-DEBUG] Recently restarted - keeping degraded', [
'source' => 'GetContainersStatus (not running)',
'app_id' => $application->id,
'app_name' => $application->name,
'old_status' => $application->status,
'new_status' => 'degraded (unhealthy)',
'restart_count' => $application->restart_count,
'last_restart_at' => $application->last_restart_at,
]);
$application->update(['status' => 'degraded (unhealthy)']);
} else {
// Reset restart count when application exits completely
Log::debug('[STATUS-DEBUG] Application not running', [
'source' => 'GetContainersStatus (not running)',
'app_id' => $application->id,
'app_name' => $application->name,
'old_status' => $application->status,
'new_status' => 'exited',
'containers_exist' => ! $this->containers->isEmpty(),
]);
$application->update([
'status' => 'exited',
'restart_count' => 0,
@ -455,15 +424,6 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
if ($aggregatedStatus) {
$statusFromDb = $application->status;
if ($statusFromDb !== $aggregatedStatus) {
Log::debug('[STATUS-DEBUG] SSH status change', [
'source' => 'GetContainersStatus',
'app_id' => $application->id,
'app_name' => $application->name,
'old_status' => $statusFromDb,
'new_status' => $aggregatedStatus,
'container_statuses' => $containerStatuses->toArray(),
'max_restart_count' => $maxRestartCount,
]);
$application->update(['status' => $aggregatedStatus]);
} else {
$application->update(['last_online_at' => now()]);
@ -473,6 +433,9 @@ public function handle(Server $server, ?Collection $containers = null, ?Collecti
}
}
// Aggregate multi-container service statuses
$this->aggregateServiceContainerStatuses($services);
ServiceChecked::dispatch($this->server->team->id);
}
@ -581,4 +544,133 @@ private function aggregateApplicationStatus($application, Collection $containerS
// All containers are exited with no restart count - truly stopped
return 'exited (unhealthy)';
}
private function aggregateServiceContainerStatuses($services)
{
if (! isset($this->serviceContainerStatuses) || $this->serviceContainerStatuses->isEmpty()) {
return;
}
foreach ($this->serviceContainerStatuses as $key => $containerStatuses) {
// Parse key: serviceId:subType:subId
[$serviceId, $subType, $subId] = explode(':', $key);
$service = $services->where('id', $serviceId)->first();
if (! $service) {
continue;
}
// Get the service sub-resource (ServiceApplication or ServiceDatabase)
$subResource = null;
if ($subType === 'application') {
$subResource = $service->applications()->where('id', $subId)->first();
} elseif ($subType === 'database') {
$subResource = $service->databases()->where('id', $subId)->first();
}
if (! $subResource) {
continue;
}
// Parse docker compose from service to check for excluded containers
$dockerComposeRaw = data_get($service, 'docker_compose_raw');
$excludedContainers = collect();
if ($dockerComposeRaw) {
try {
$dockerCompose = \Symfony\Component\Yaml\Yaml::parse($dockerComposeRaw);
$servicesInCompose = data_get($dockerCompose, 'services', []);
foreach ($servicesInCompose as $serviceName => $serviceConfig) {
// Check if container should be excluded
$excludeFromHc = data_get($serviceConfig, 'exclude_from_hc', false);
$restartPolicy = data_get($serviceConfig, 'restart', 'always');
if ($excludeFromHc || $restartPolicy === 'no') {
$excludedContainers->push($serviceName);
}
}
} catch (\Exception $e) {
// If we can't parse, treat all containers as included
}
}
// Filter out excluded containers
$relevantStatuses = $containerStatuses->filter(function ($status, $containerName) use ($excludedContainers) {
return ! $excludedContainers->contains($containerName);
});
// If all containers are excluded, don't update status
if ($relevantStatuses->isEmpty()) {
continue;
}
// Aggregate status using same logic as applications
$hasRunning = false;
$hasRestarting = false;
$hasUnhealthy = false;
$hasUnknown = false;
$hasExited = false;
$hasStarting = false;
$hasPaused = false;
$hasDead = false;
foreach ($relevantStatuses as $status) {
if (str($status)->contains('restarting')) {
$hasRestarting = true;
} elseif (str($status)->contains('running')) {
$hasRunning = true;
if (str($status)->contains('unhealthy')) {
$hasUnhealthy = true;
}
if (str($status)->contains('unknown')) {
$hasUnknown = true;
}
} elseif (str($status)->contains('exited')) {
$hasExited = true;
$hasUnhealthy = true;
} elseif (str($status)->contains('created') || str($status)->contains('starting')) {
$hasStarting = true;
} elseif (str($status)->contains('paused')) {
$hasPaused = true;
} elseif (str($status)->contains('dead') || str($status)->contains('removing')) {
$hasDead = true;
}
}
$aggregatedStatus = null;
if ($hasRestarting) {
$aggregatedStatus = 'degraded (unhealthy)';
} elseif ($hasRunning && $hasExited) {
$aggregatedStatus = 'degraded (unhealthy)';
} elseif ($hasRunning) {
if ($hasUnhealthy) {
$aggregatedStatus = 'running (unhealthy)';
} elseif ($hasUnknown) {
$aggregatedStatus = 'running (unknown)';
} else {
$aggregatedStatus = 'running (healthy)';
}
} elseif ($hasDead) {
$aggregatedStatus = 'degraded (unhealthy)';
} elseif ($hasPaused) {
$aggregatedStatus = 'paused (unknown)';
} elseif ($hasStarting) {
$aggregatedStatus = 'starting (unknown)';
} else {
// All containers are exited
$aggregatedStatus = 'exited (unhealthy)';
}
// Update service sub-resource status with aggregated result
if ($aggregatedStatus) {
$statusFromDb = $subResource->status;
if ($statusFromDb !== $aggregatedStatus) {
$subResource->update(['status' => $aggregatedStatus]);
} else {
$subResource->update(['last_online_at' => now()]);
}
}
}
}
}

199
app/Jobs/PushServerUpdateJob.php
View file

@ -21,7 +21,6 @@
use Illuminate\Queue\Middleware\WithoutOverlapping;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Log;
use Laravel\Horizon\Contracts\Silenced;
class PushServerUpdateJob implements ShouldBeEncrypted, ShouldQueue, Silenced
@ -68,6 +67,8 @@ class PushServerUpdateJob implements ShouldBeEncrypted, ShouldQueue, Silenced
public Collection $applicationContainerStatuses;
public Collection $serviceContainerStatuses;
public bool $foundProxy = false;
public bool $foundLogDrainContainer = false;
@ -91,6 +92,7 @@ public function __construct(public Server $server, public $data)
$this->foundApplicationPreviewsIds = collect();
$this->foundServiceDatabaseIds = collect();
$this->applicationContainerStatuses = collect();
$this->serviceContainerStatuses = collect();
$this->allApplicationIds = collect();
$this->allDatabaseUuids = collect();
$this->allTcpProxyUuids = collect();
@ -109,14 +111,6 @@ public function handle()
$this->server->sentinelHeartbeat();
$this->containers = collect(data_get($data, 'containers'));
Log::debug('[STATUS-DEBUG] Raw Sentinel data received', [
'source' => 'PushServerUpdateJob',
'container_count' => $this->containers->count(),
'containers' => $this->containers->toArray(),
]);
ray('Raw Sentinel containers:', $this->containers->toArray());
$filesystemUsageRoot = data_get($data, 'filesystem_usage_root.used_percentage');
ServerStorageCheckJob::dispatch($this->server, $filesystemUsageRoot);
@ -149,25 +143,13 @@ public function handle()
foreach ($this->containers as $container) {
$containerStatus = data_get($container, 'state', 'exited');
$containerHealth = data_get($container, 'health_status', 'unhealthy');
$rawHealthStatus = data_get($container, 'health_status');
$containerHealth = $rawHealthStatus ?? 'unknown';
$containerStatus = "$containerStatus ($containerHealth)";
$labels = collect(data_get($container, 'labels'));
$coolify_managed = $labels->has('coolify.managed');
Log::debug('[STATUS-DEBUG] Processing container from Sentinel', [
'source' => 'PushServerUpdateJob (loop)',
'container_name' => data_get($container, 'name'),
'container_status' => $containerStatus,
'labels' => $labels->toArray(),
'has_coolify_managed' => $coolify_managed,
]);
if (! $coolify_managed) {
Log::debug('[STATUS-DEBUG] Container skipped - not coolify managed', [
'source' => 'PushServerUpdateJob',
'container_name' => data_get($container, 'name'),
]);
continue;
}
@ -191,19 +173,6 @@ public function handle()
$containerName = $labels->get('com.docker.compose.service');
if ($containerName) {
$this->applicationContainerStatuses->get($applicationId)->put($containerName, $containerStatus);
Log::debug('[STATUS-DEBUG] Container added to applicationContainerStatuses', [
'source' => 'PushServerUpdateJob',
'application_id' => $applicationId,
'container_name' => $containerName,
'container_status' => $containerStatus,
]);
} else {
Log::debug('[STATUS-DEBUG] Container skipped - no com.docker.compose.service label', [
'source' => 'PushServerUpdateJob',
'container_name' => data_get($container, 'name'),
'application_id' => $applicationId,
'labels' => $labels->toArray(),
]);
}
} else {
$previewKey = $applicationId.':'.$pullRequestId;
@ -218,12 +187,32 @@ public function handle()
$serviceId = $labels->get('coolify.serviceId');
$subType = $labels->get('coolify.service.subType');
$subId = $labels->get('coolify.service.subId');
if ($subType === 'application' && $this->isRunning($containerStatus)) {
$this->foundServiceApplicationIds->push($subId);
$this->updateServiceSubStatus($serviceId, $subType, $subId, $containerStatus);
} elseif ($subType === 'database' && $this->isRunning($containerStatus)) {
$this->foundServiceDatabaseIds->push($subId);
$this->updateServiceSubStatus($serviceId, $subType, $subId, $containerStatus);
if ($subType === 'application') {
if ($this->isRunning($containerStatus)) {
$this->foundServiceApplicationIds->push($subId);
}
// Store container status for aggregation
$key = $serviceId.':'.$subType.':'.$subId;
if (! $this->serviceContainerStatuses->has($key)) {
$this->serviceContainerStatuses->put($key, collect());
}
$containerName = $labels->get('com.docker.compose.service');
if ($containerName) {
$this->serviceContainerStatuses->get($key)->put($containerName, $containerStatus);
}
} elseif ($subType === 'database') {
if ($this->isRunning($containerStatus)) {
$this->foundServiceDatabaseIds->push($subId);
}
// Store container status for aggregation
$key = $serviceId.':'.$subType.':'.$subId;
if (! $this->serviceContainerStatuses->has($key)) {
$this->serviceContainerStatuses->put($key, collect());
}
$containerName = $labels->get('com.docker.compose.service');
if ($containerName) {
$this->serviceContainerStatuses->get($key)->put($containerName, $containerStatus);
}
}
} else {
$uuid = $labels->get('com.docker.compose.service');
@ -257,27 +246,20 @@ public function handle()
// Aggregate multi-container application statuses
$this->aggregateMultiContainerStatuses();
// Aggregate multi-container service statuses
$this->aggregateServiceContainerStatuses();
$this->checkLogDrainContainer();
}
private function aggregateMultiContainerStatuses()
{
Log::debug('[STATUS-DEBUG] Starting aggregation of multi-container application statuses', [
'source' => 'PushServerUpdateJob',
]);
ray('Starting aggregation of multi-container application statuses');
ray($this->applicationContainerStatuses->toArray());
if ($this->applicationContainerStatuses->isEmpty()) {
return;
}
foreach ($this->applicationContainerStatuses as $applicationId => $containerStatuses) {
$application = $this->applications->where('id', $applicationId)->first();
Log::debug('[STATUS-DEBUG] Processing application for aggregation', [
'source' => 'PushServerUpdateJob',
'app_id' => $applicationId,
'container_statuses' => $containerStatuses->toArray(),
]);
if (! $application) {
continue;
}
@ -345,19 +327,7 @@ private function aggregateMultiContainerStatuses()
// All containers are exited
$aggregatedStatus = 'exited (unhealthy)';
}
Log::debug('[STATUS-DEBUG] Sentinel status change', [
'source' => 'PushServerUpdateJob',
'app_id' => $application->id,
'app_name' => $application->name,
'old_status' => $application->status,
'new_status' => $aggregatedStatus,
'container_statuses' => $relevantStatuses->toArray(),
'flags' => [
'hasRunning' => $hasRunning,
'hasUnhealthy' => $hasUnhealthy,
'hasUnknown' => $hasUnknown,
],
]);
// Update application status with aggregated result
if ($aggregatedStatus && $application->status !== $aggregatedStatus) {
@ -367,6 +337,105 @@ private function aggregateMultiContainerStatuses()
}
}
private function aggregateServiceContainerStatuses()
{
if ($this->serviceContainerStatuses->isEmpty()) {
return;
}
foreach ($this->serviceContainerStatuses as $key => $containerStatuses) {
// Parse key: serviceId:subType:subId
[$serviceId, $subType, $subId] = explode(':', $key);
$service = $this->services->where('id', $serviceId)->first();
if (! $service) {
continue;
}
// Get the service sub-resource (ServiceApplication or ServiceDatabase)
$subResource = null;
if ($subType === 'application') {
$subResource = $service->applications()->where('id', $subId)->first();
} elseif ($subType === 'database') {
$subResource = $service->databases()->where('id', $subId)->first();
}
if (! $subResource) {
continue;
}
// Parse docker compose from service to check for excluded containers
$dockerComposeRaw = data_get($service, 'docker_compose_raw');
$excludedContainers = collect();
if ($dockerComposeRaw) {
try {
$dockerCompose = \Symfony\Component\Yaml\Yaml::parse($dockerComposeRaw);
$services = data_get($dockerCompose, 'services', []);
foreach ($services as $serviceName => $serviceConfig) {
// Check if container should be excluded
$excludeFromHc = data_get($serviceConfig, 'exclude_from_hc', false);
$restartPolicy = data_get($serviceConfig, 'restart', 'always');
if ($excludeFromHc || $restartPolicy === 'no') {
$excludedContainers->push($serviceName);
}
}
} catch (\Exception $e) {
// If we can't parse, treat all containers as included
}
}
// Filter out excluded containers
$relevantStatuses = $containerStatuses->filter(function ($status, $containerName) use ($excludedContainers) {
return ! $excludedContainers->contains($containerName);
});
// If all containers are excluded, don't update status
if ($relevantStatuses->isEmpty()) {
continue;
}
// Aggregate status: if any container is running, service is running
$hasRunning = false;
$hasUnhealthy = false;
$hasUnknown = false;
foreach ($relevantStatuses as $status) {
if (str($status)->contains('running')) {
$hasRunning = true;
if (str($status)->contains('unhealthy')) {
$hasUnhealthy = true;
}
if (str($status)->contains('unknown')) {
$hasUnknown = true;
}
}
}
$aggregatedStatus = null;
if ($hasRunning) {
if ($hasUnhealthy) {
$aggregatedStatus = 'running (unhealthy)';
} elseif ($hasUnknown) {
$aggregatedStatus = 'running (unknown)';
} else {
$aggregatedStatus = 'running (healthy)';
}
} else {
// All containers are exited
$aggregatedStatus = 'exited (unhealthy)';
}
// Update service sub-resource status with aggregated result
if ($aggregatedStatus && $subResource->status !== $aggregatedStatus) {
$subResource->status = $aggregatedStatus;
$subResource->save();
}
}
}
private function updateApplicationStatus(string $applicationId, string $containerStatus)
{
$application = $this->applications->where('id', $applicationId)->first();

90
tests/Unit/GetContainersStatusServiceAggregationTest.php Normal file
View file

@ -0,0 +1,90 @@
<?php
/**
* Unit tests for GetContainersStatus service aggregation logic (SSH path).
*
* These tests verify that the SSH-based status updates (GetContainersStatus)
* correctly aggregates container statuses for services with multiple containers,
* using the same logic as PushServerUpdateJob (Sentinel path).
*
* This ensures consistency across both status update paths and prevents
* race conditions where the last container processed wins.
*/
it('implements service multi-container aggregation in SSH path', function () {
$actionFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Verify service container collection property exists
expect($actionFile)
->toContain('protected ?Collection $serviceContainerStatuses;');
// Verify aggregateServiceContainerStatuses method exists
expect($actionFile)
->toContain('private function aggregateServiceContainerStatuses($services)')
->toContain('$this->aggregateServiceContainerStatuses($services);');
// Verify service aggregation uses same logic as applications
expect($actionFile)
->toContain('$hasUnknown = false;');
});
it('services use same priority as applications in SSH path', function () {
$actionFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Both aggregation methods should use the same priority logic
$priorityLogic = <<<'PHP'
if ($hasUnhealthy) {
$aggregatedStatus = 'running (unhealthy)';
} elseif ($hasUnknown) {
$aggregatedStatus = 'running (unknown)';
} else {
$aggregatedStatus = 'running (healthy)';
}
PHP;
// Should appear in service aggregation
expect($actionFile)->toContain($priorityLogic);
});
it('collects service containers before aggregating in SSH path', function () {
$actionFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Verify service containers are collected, not immediately updated
expect($actionFile)
->toContain('$key = $serviceLabelId.\':\'.$subType.\':\'.$subId;')
->toContain('$this->serviceContainerStatuses->get($key)->put($containerName, $containerStatus);');
// Verify aggregation happens before ServiceChecked dispatch
expect($actionFile)
->toContain('$this->aggregateServiceContainerStatuses($services);')
->toContain('ServiceChecked::dispatch($this->server->team->id);');
});
it('SSH and Sentinel paths use identical service aggregation logic', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
$actionFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Both should track the same status flags
expect($jobFile)->toContain('$hasUnknown = false;');
expect($actionFile)->toContain('$hasUnknown = false;');
// Both should check for unknown status
expect($jobFile)->toContain('if (str($status)->contains(\'unknown\')) {');
expect($actionFile)->toContain('if (str($status)->contains(\'unknown\')) {');
// Both should have elseif for unknown priority
expect($jobFile)->toContain('} elseif ($hasUnknown) {');
expect($actionFile)->toContain('} elseif ($hasUnknown) {');
});
it('handles service status updates consistently', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
$actionFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Both should parse service key with same format
expect($jobFile)->toContain('[$serviceId, $subType, $subId] = explode(\':\', $key);');
expect($actionFile)->toContain('[$serviceId, $subType, $subId] = explode(\':\', $key);');
// Both should handle excluded containers
expect($jobFile)->toContain('$excludedContainers = collect();');
expect($actionFile)->toContain('$excludedContainers = collect();');
});

77
tests/Unit/PushServerUpdateJobStatusAggregationTest.php
View file

@ -105,3 +105,80 @@
->toContain('} elseif ($hasUnknown) {')
->toContain('$aggregatedStatus = \'running (unknown)\';');
});
it('implements service multi-container aggregation', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
// Verify service container collection exists
expect($jobFile)
->toContain('public Collection $serviceContainerStatuses;')
->toContain('$this->serviceContainerStatuses = collect();');
// Verify aggregateServiceContainerStatuses method exists
expect($jobFile)
->toContain('private function aggregateServiceContainerStatuses()')
->toContain('$this->aggregateServiceContainerStatuses();');
// Verify service aggregation uses same logic as applications
expect($jobFile)
->toContain('$hasUnknown = false;');
});
it('services use same priority as applications', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
// Both aggregation methods should use the same priority logic
$applicationAggregation = <<<'PHP'
if ($hasUnhealthy) {
$aggregatedStatus = 'running (unhealthy)';
} elseif ($hasUnknown) {
$aggregatedStatus = 'running (unknown)';
} else {
$aggregatedStatus = 'running (healthy)';
}
PHP;
// Count occurrences - should appear twice (once for apps, once for services)
$occurrences = substr_count($jobFile, $applicationAggregation);
expect($occurrences)->toBeGreaterThanOrEqual(2, 'Priority logic should appear for both applications and services');
});
it('collects service containers before aggregating', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
// Verify service containers are collected, not immediately updated
expect($jobFile)
->toContain('$key = $serviceId.\':\'.$subType.\':\'.$subId;')
->toContain('$this->serviceContainerStatuses->get($key)->put($containerName, $containerStatus);');
// Verify aggregation happens after collection
expect($jobFile)
->toContain('$this->aggregateMultiContainerStatuses();')
->toContain('$this->aggregateServiceContainerStatuses();');
});
it('defaults to unknown when health_status is missing from Sentinel data', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
// Verify we use null coalescing to default to 'unknown', not 'unhealthy'
// This is critical for containers without healthcheck defined
expect($jobFile)
->toContain('$rawHealthStatus = data_get($container, \'health_status\');')
->toContain('$containerHealth = $rawHealthStatus ?? \'unknown\';')
->not->toContain('data_get($container, \'health_status\', \'unhealthy\')');
});
it('matches SSH path default health status behavior', function () {
$jobFile = file_get_contents(__DIR__.'/../../app/Jobs/PushServerUpdateJob.php');
$getContainersFile = file_get_contents(__DIR__.'/../../app/Actions/Docker/GetContainersStatus.php');
// Both paths should default to 'unknown' when health status is missing
// Sentinel path: health_status field missing -> 'unknown'
expect($jobFile)->toContain('?? \'unknown\'');
// SSH path: State.Health.Status missing -> 'unknown'
expect($getContainersFile)->toContain('?? \'unknown\'');
// Neither should use 'unhealthy' as default for missing health status
expect($jobFile)->not->toContain('data_get($container, \'health_status\', \'unhealthy\')');
});