DevLinkInstall.php

<?php

namespace ProcessMaker\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Http\Client\RequestException;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use ProcessMaker\Exception\DevLinkRemoteBundleException;
use ProcessMaker\Exception\DevLinkRemoteValidationException;
use ProcessMaker\Exception\ValidationException;
use ProcessMaker\ImportExport\Logger;
use ProcessMaker\Jobs\ImportV2;
use ProcessMaker\Models\Bundle;
use ProcessMaker\Models\DevLink;
use Throwable;

class DevLinkInstall implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    private const REMOTE_ERROR_MESSAGE = 'The remote instance could not complete the DevLink request. Check the source instance logs and try again.';

    private const UNEXPECTED_ERROR_MESSAGE = 'The DevLink operation could not be completed. Check the target instance logs and try again.';

    const TYPE_INSTALL_BUNDLE = 'install_bundle';

    const TYPE_REINSTALL_BUNDLE = 'reinstall_bundle';

    const TYPE_IMPORT_ASSET = 'import_asset';

    const MODE_UPDATE = 'update';

    const MODE_COPY = 'copy';

    public $tries = 1;

    public $maxExceptions = 1;

    /**
     * Correlates progress events with the DevLink operation that started them.
     *
     * This remains nullable so jobs queued before this property was introduced
     * can still be processed after an application upgrade.
     */
    public $operationId = null;

    public function __construct(
        public int $userId,
        public int $devLinkId,
        public string $class,
        public int $id,
        public string $importMode,
        public string $type,
        $operationId = null,
    ) {
        $this->operationId = $operationId;
    }

    /**
     * Execute the job.
     */
    public function handle(): void
    {
        //log
        Log::info('DevLinkInstall job started: ' . $this->devLinkId);
        $devLink = DevLink::findOrFail($this->devLinkId);
        $logger = new Logger($this->userId, $this->operationId);

        $lock = Cache::lock(ImportV2::CACHE_LOCK_KEY, ImportV2::RELEASE_LOCK_AFTER);

        if ($lock->get()) {
            DB::transaction(function () use ($devLink, $logger) {
                switch($this->type) {
                    case self::TYPE_INSTALL_BUNDLE:
                        $devLink->logger = $logger;
                        $devLink->installRemoteBundle($this->id, $this->importMode);
                        break;
                    case self::TYPE_REINSTALL_BUNDLE:
                        $bundle = Bundle::findOrFail($this->id);
                        $bundle->reinstall($this->importMode, $logger);
                        break;
                    case self::TYPE_IMPORT_ASSET:
                        $devLink->installRemoteAsset($this->class, $this->id, $this->importMode, $logger);
                        break;
                    default:
                        break;
                }
            });
            $lock->release();
        } else {
            // Don't throw exception because that will unlock the running job
            $logger->error('Already running!');
        }
    }

    public function failed(Throwable $exception): void
    {
        $logger = new Logger($this->userId, $this->operationId);

        Log::error('DevLink operation failed.', [
            'exception' => $exception,
            'operation_id' => $this->operationId,
            'dev_link_id' => $this->devLinkId,
            'type' => $this->type,
        ]);

        if (
            $exception instanceof DevLinkRemoteBundleException
            || $exception instanceof DevLinkRemoteValidationException
            || $exception instanceof ValidationException
        ) {
            $message = $exception instanceof ValidationException
                ? collect($exception->errors())->flatten()->first(fn ($message) => is_string($message))
                : $exception->getMessage();
            $logger->error($message ?: $exception->getMessage());
        } elseif ($exception instanceof RequestException) {
            $logger->error(__(self::REMOTE_ERROR_MESSAGE));
        } else {
            $logger->error(__(self::UNEXPECTED_ERROR_MESSAGE));
        }

        // Unlock the job
        // We can't use $this->lock->release() here because this is run in a new instance
        Cache::lock(ImportV2::CACHE_LOCK_KEY)->forceRelease();
    }
}