app/Jobs/SyncGithubDeploymentJob.php
Rama main · réplica de lectura del repositorio original.
<?php
namespace App\Jobs;
use App\Enums\ApplicationDeploymentStatus;
use App\Models\Application;
use App\Models\ApplicationDeploymentQueue;
use App\Models\GithubApp;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldBeEncrypted;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\Middleware\WithoutOverlapping;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;
use Throwable;
/**
* Mirrors the status of a Coolify deployment to a GitHub Deployment, so GitHub shows the
* branch or pull request as deployed. Each run sends the current status, so a late or
* repeated run converges to the same result.
*/
class SyncGithubDeploymentJob implements ShouldBeEncrypted, ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable;
/**
* API errors are tried three times. Waits for the per-deployment lock are not counted, so a
* terminal sync that waits behind a slow sync still runs (see retryUntil()).
*/
public $maxExceptions = 3;
public $backoff = 10;
/**
* Seconds that one request waits for GitHub. A slow GitHub must not hold a queue worker.
*/
public const HTTP_TIMEOUT_SECONDS = 10;
/**
* Longer than the worst case of all requests with their retries, shorter than the lock
* expiry, so the per-deployment lock is held while the job runs.
*/
public $timeout = 100;
private const LOCK_EXPIRES_AFTER = 120;
private const LOCK_RELEASE_DELAY = 5;
public function __construct(public int $deploymentQueueId, public bool $deactivate = false)
{
// Not the deployment queue: a slow GitHub must not delay deployments.
$this->onQueue('default');
}
/**
* Queue a sync when the deployment belongs to a GitHub App that can write deployments.
*/
public static function dispatchFor(ApplicationDeploymentQueue $deployment): void
{
if (filled($deployment->parent_deployment_uuid)) {
// Deployments to additional servers are part of the main deployment.
return;
}
// A soft-deleted application still needs its last status on GitHub.
$source = Application::withTrashed()->find($deployment->application_id)?->source;
if (! $source instanceof GithubApp || ! $source->canSyncDeployments()) {
return;
}
self::dispatch($deployment->id);
}
/**
* Mark the GitHub Deployments of a closed pull request as inactive. This also covers
* deployments that GitHub does not know yet, so a late sync cannot create one.
*/
public static function deactivatePullRequest(Application $application, int $pullRequestId): void
{
ApplicationDeploymentQueue::query()
->where('application_id', $application->id)
->where('pull_request_id', $pullRequestId)
->where(fn ($query) => $query->whereNull('github_deployment_state')->orWhere('github_deployment_state', '!=', 'inactive'))
->pluck('id')
->each(fn (int $deploymentQueueId) => self::dispatch($deploymentQueueId, deactivate: true));
}
/**
* All syncs of one deployment share this lock, and handle() reads the state while it
* holds the lock. Thus a deactivation cannot happen between that read and the requests.
*
* @return array<int, object>
*/
public function middleware(): array
{
return [(new WithoutOverlapping("github-deployment:{$this->deploymentQueueId}"))->releaseAfter(self::LOCK_RELEASE_DELAY)->expireAfter(self::LOCK_EXPIRES_AFTER)];
}
/**
* A sync can wait for a lock that is held up to its expiry. Fixed at dispatch.
*/
public function retryUntil(): \DateTimeInterface
{
return now()->addSeconds(self::LOCK_EXPIRES_AFTER + 60);
}
public function handle(): void
{
$deployment = ApplicationDeploymentQueue::find($this->deploymentQueueId);
$application = $deployment ? Application::withTrashed()->find($deployment->application_id) : null;
$source = $application?->source;
if (! $source instanceof GithubApp || ! $source->canSyncDeployments()) {
return;
}
// Inactive is the end state: a closed pull request must not show as deployed again.
if ($deployment->github_deployment_state === 'inactive') {
return;
}
$state = $this->deactivate ? 'inactive' : $this->githubState($deployment->status);
if ($state === null || $state === $deployment->github_deployment_state) {
return;
}
$repository = gitRepositorySlug($application->git_repository);
$githubDeploymentId = $deployment->github_deployment_id;
if (! $githubDeploymentId) {
if ($state === 'inactive') {
// Keep the marker, so a late sync does not create a GitHub Deployment.
ApplicationDeploymentQueue::whereKey($deployment->id)->update(['github_deployment_state' => 'inactive']);
return;
}
// The deployment ended before GitHub knew about it. The deployment job sets
// horizon_job_worker together with IN_PROGRESS, so a failure without it never started.
if ($state === 'error' || ($state === 'failure' && blank($deployment->horizon_job_worker))) {
return;
}
$githubDeploymentId = $this->createGithubDeployment($deployment, $application, $source, $repository);
ApplicationDeploymentQueue::whereKey($deployment->id)->update(['github_deployment_id' => $githubDeploymentId]);
}
githubApi($source, "repos/{$repository}/deployments/{$githubDeploymentId}/statuses", 'post', array_filter([
'state' => $state,
'description' => $this->description($state),
'log_url' => $this->logUrl($deployment, $application),
'environment_url' => $state === 'success' ? $this->environmentUrl($deployment, $application) : null,
]), timeout: self::HTTP_TIMEOUT_SECONDS);
ApplicationDeploymentQueue::whereKey($deployment->id)->update(['github_deployment_state' => $state]);
}
public function failed(Throwable $exception): void
{
Log::warning('Failed to sync the GitHub deployment.', [
'deployment_queue_id' => $this->deploymentQueueId,
'error' => $exception->getMessage(),
]);
}
private function githubState(string $status): ?string
{
return match ($status) {
ApplicationDeploymentStatus::IN_PROGRESS->value => 'in_progress',
ApplicationDeploymentStatus::FINISHED->value => 'success',
ApplicationDeploymentStatus::FAILED->value => 'failure',
ApplicationDeploymentStatus::CANCELLED_BY_USER->value => 'error',
default => null,
};
}
private function createGithubDeployment(ApplicationDeploymentQueue $deployment, Application $application, GithubApp $source, string $repository): int
{
$isPreview = $deployment->pull_request_id !== 0;
$environment = $isPreview ? "{$application->name} (preview)" : $application->name;
$response = githubApi($source, "repos/{$repository}/deployments", 'post', [
'ref' => $this->ref($deployment, $application, $source, $repository),
'environment' => Str::limit($environment, 255, ''),
'description' => Str::limit($isPreview ? "Coolify preview for PR #{$deployment->pull_request_id}" : 'Coolify deployment', 140, ''),
// GitHub would merge the default branch into the ref, or wait for all commit checks.
'auto_merge' => false,
'required_contexts' => [],
'transient_environment' => $isPreview,
'production_environment' => ! $isPreview,
], timeout: self::HTTP_TIMEOUT_SECONDS);
return (int) $response['data']->get('id');
}
/**
* GitHub links a deployment to a pull request only when its ref is the head branch. A fork
* branch is not in the base repository, so a fork preview uses the head commit. GitHub
* resolves a branch to its current commit, so the branch is used only while it still
* points to the deployed commit.
*/
private function ref(ApplicationDeploymentQueue $deployment, Application $application, GithubApp $source, string $repository): string
{
$commit = filled($deployment->commit) && $deployment->commit !== 'HEAD' ? $deployment->commit : null;
if ($deployment->pull_request_id !== 0) {
$pullRequest = githubApi($source, "repos/{$repository}/pulls/{$deployment->pull_request_id}", timeout: self::HTTP_TIMEOUT_SECONDS)['data'];
$headRepository = (string) data_get($pullRequest, 'head.repo.full_name', '');
$baseRepository = (string) data_get($pullRequest, 'base.repo.full_name', $repository);
$headBranch = data_get($pullRequest, 'head.ref');
$headCommit = (string) data_get($pullRequest, 'head.sha');
$isDeployedCommit = $commit === null || strcasecmp($commit, $headCommit) === 0;
if (filled($headBranch) && strcasecmp($headRepository, $baseRepository) === 0 && $isDeployedCommit) {
return $headBranch;
}
return $commit ?? $headCommit;
}
// The branch can move past the deployed commit before the GitHub deployment is created.
return $commit ?? $application->git_branch;
}
private function description(string $state): string
{
return match ($state) {
'in_progress' => 'Deploying with Coolify.',
'success' => 'Deployed with Coolify.',
'failure' => 'The Coolify deployment failed.',
'error' => 'The Coolify deployment was cancelled.',
default => 'The pull request was closed.',
};
}
private function logUrl(ApplicationDeploymentQueue $deployment, Application $application): string
{
return base_url()."/project/{$application->environment->project->uuid}/environment/{$application->environment->uuid}/application/{$application->uuid}/deployment/{$deployment->deployment_uuid}";
}
private function environmentUrl(ApplicationDeploymentQueue $deployment, Application $application): ?string
{
if ($deployment->pull_request_id !== 0) {
$preview = $application->previews()->where('pull_request_id', $deployment->pull_request_id)->first();
$domains = $application->build_pack === 'dockercompose'
? collect(json_decode((string) $preview?->docker_compose_domains, true) ?: [])->pluck('domain')->filter()->first()
: $preview?->fqdn;
} else {
$domains = $application->build_pack === 'dockercompose'
? collect(json_decode((string) $application->docker_compose_domains, true) ?: [])->pluck('domain')->filter()->first()
: $application->fqdn;
}
$url = trim((string) str($domains)->explode(',')->first());
return str_starts_with($url, 'http://') || str_starts_with($url, 'https://') ? $url : null;
}
}