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.

5.3 KB
Raw Blame
<?php

namespace App\Livewire\Project\Shared\ScheduledTask;

use App\Models\ScheduledTask;
use App\Traits\ListensToTeamChannel;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Auth;
use Livewire\Attributes\Computed;
use Livewire\Attributes\Locked;
use Livewire\Component;

class Executions extends Component
{
    use ListensToTeamChannel;

    #[Locked]
    public int $taskId;

    #[Locked]
    public Collection $executions;

    #[Locked]
    public ?int $selectedKey = null;

    #[Locked]
    public ?string $serverTimezone = null;

    public $currentPage = 1;

    public $logsPerPage = 100;

    #[Locked]
    public $selectedExecution = null;

    public $isPollingActive = false;

    public function getListeners()
    {
        return $this->teamChannelListeners([
            'ScheduledTaskDone' => 'refreshExecutions',
        ]);
    }

    public function mount($taskId)
    {
        try {
            $this->taskId = $taskId;
            $task = ScheduledTask::where('team_id', Auth::user()->currentTeam()->id)->findOrFail($taskId);
            $this->executions = $task->executions()->take(20)->get();
            $this->serverTimezone = data_get($task, 'application.destination.server.settings.server_timezone');
            if (! $this->serverTimezone) {
                $this->serverTimezone = data_get($task, 'service.destination.server.settings.server_timezone');
            }
            if (! $this->serverTimezone) {
                $this->serverTimezone = 'UTC';
            }
        } catch (\Exception $e) {
            return handleError($e);
        }
    }

    /**
     * Load the task on each request instead of storing it as a model property. A stored model fails
     * with a 404 when the poll runs after the task is deleted and before the page navigates away.
     */
    #[Computed]
    public function task(): ?ScheduledTask
    {
        return ScheduledTask::find($this->taskId);
    }

    public function refreshExecutions(): void
    {
        if (! $this->task) {
            return;
        }

        $this->executions = $this->task->executions()->take(20)->get();
        if ($this->selectedKey) {
            $this->selectedExecution = $this->task->executions()->find($this->selectedKey);
            if ($this->selectedExecution && $this->selectedExecution->status !== 'running') {
                $this->isPollingActive = false;
            }
        }
    }

    public function selectTask($key): void
    {
        if ($key == $this->selectedKey) {
            $this->selectedKey = null;
            $this->selectedExecution = null;
            $this->currentPage = 1;
            $this->isPollingActive = false;

            return;
        }
        $this->selectedKey = $key;
        $this->selectedExecution = $this->task?->executions()->find($key);
        $this->currentPage = 1;

        // Start polling if task is running
        if ($this->selectedExecution && $this->selectedExecution->status === 'running') {
            $this->isPollingActive = true;
        }
    }

    public function polling()
    {
        if ($this->selectedExecution && $this->isPollingActive) {
            $this->selectedExecution->refresh();
            if ($this->selectedExecution->status !== 'running') {
                $this->isPollingActive = false;
            }
        }
    }

    public function loadMoreLogs()
    {
        $this->currentPage++;
    }

    public function loadAllLogs()
    {
        if (! $this->selectedExecution || ! $this->selectedExecution->message) {
            return;
        }

        $lines = collect(explode("\n", $this->selectedExecution->message));
        $totalLines = $lines->count();
        $totalPages = ceil($totalLines / $this->logsPerPage);

        $this->currentPage = $totalPages;
    }

    public function getLogLinesProperty()
    {
        if (! $this->selectedExecution) {
            return collect();
        }

        if (! $this->canReadOutput()) {
            return collect(['Hidden (only admins can view)']);
        }

        if (! $this->selectedExecution->message) {
            return collect(['Waiting for task output...']);
        }

        $lines = collect(explode("\n", $this->selectedExecution->message));

        return $lines->take($this->currentPage * $this->logsPerPage);
    }

    public function downloadLogs(int $executionId)
    {
        $execution = $this->executions->firstWhere('id', $executionId);
        if (! $execution || ! $this->canReadOutput()) {
            return;
        }

        return response()->streamDownload(function () use ($execution) {
            echo $execution->message;
        }, 'task-execution-'.$execution->id.'.log');
    }

    /**
     * Task output can contain secrets, so only users who can edit the task's resource may read it.
     */
    public function canReadOutput(): bool
    {
        $resource = $this->task?->application ?? $this->task?->service;

        return $resource && auth()->user()?->can('update', $resource);
    }

    public function hasMoreLogs()
    {
        if (! $this->selectedExecution || ! $this->selectedExecution->message || ! $this->canReadOutput()) {
            return false;
        }
        $lines = collect(explode("\n", $this->selectedExecution->message));

        return $lines->count() > ($this->currentPage * $this->logsPerPage);
    }
}