FM / Queue

/home/techb158/immovalet.com/vendor/laravel/framework/src/Illuminate/Queue/

/home/techb158/immovalet.com/vendor/laravel/framework/src/Illuminate/Queue

Name	Size	Mode	Actions
Capsule/	-	0755	rm
Connectors/	-	0755	rm
Console/	-	0755	rm
Events/	-	0755	rm
Failed/	-	0755	rm
Jobs/	-	0755	rm
Middleware/	-	0755	rm
BeanstalkdQueue.php	4849	0644	edit dl rm
CallQueuedClosure.php	2590	0644	edit dl rm
CallQueuedHandler.php	8374	0644	edit dl rm
composer.json	1619	0644	edit dl rm
DatabaseQueue.php	11099	0644	edit dl rm
InteractsWithQueue.php	1397	0644	edit dl rm
InvalidPayloadException.php	375	0644	edit dl rm
LICENSE.md	1075	0644	edit dl rm
Listener.php	5643	0644	edit dl rm
ListenerOptions.php	839	0644	edit dl rm
LuaScripts.php	4419	0644	edit dl rm
ManuallyFailedException.php	125	0644	edit dl rm
MaxAttemptsExceededException.php	130	0644	edit dl rm
NullQueue.php	1422	0644	edit dl rm
Queue.php	10677	0644	edit dl rm
QueueManager.php	6851	0644	edit dl rm
QueueServiceProvider.php	8099	0644	edit dl rm
README.md	1217	0644	edit dl rm
RedisQueue.php	9434	0644	edit dl rm
SerializableClosure.php	954	0644	edit dl rm
SerializesAndRestoresModelIdentifiers.php	3468	0644	edit dl rm
SerializesModels.php	3325	0644	edit dl rm
SqsQueue.php	5201	0644	edit dl rm
SyncQueue.php	3950	0644	edit dl rm
Worker.php	24543	0644	edit dl rm
WorkerOptions.php	2413	0644	edit dl rm

Edit: /home/techb158/immovalet.com/vendor/laravel/framework/src/Illuminate/Queue/Listener.php (5643B)

<?php

namespace Illuminate\Queue;

use Closure;
use Symfony\Component\Process\PhpExecutableFinder;
use Symfony\Component\Process\Process;

class Listener
{
    /**
     * The command working path.
     *
     * @var string
     */
    protected $commandPath;

/**
     * The environment the workers should run under.
     *
     * @var string
     */
    protected $environment;

/**
     * The amount of seconds to wait before polling the queue.
     *
     * @var int
     */
    protected $sleep = 3;

/**
     * The amount of times to try a job before logging it failed.
     *
     * @var int
     */
    protected $maxTries = 0;

/**
     * The output handler callback.
     *
     * @var \Closure|null
     */
    protected $outputHandler;

/**
     * Create a new queue listener.
     *
     * @param  string  $commandPath
     * @return void
     */
    public function __construct($commandPath)
    {
        $this->commandPath = $commandPath;
    }

/**
     * Get the PHP binary.
     *
     * @return string
     */
    protected function phpBinary()
    {
        return (new PhpExecutableFinder)->find(false);
    }

/**
     * Get the Artisan binary.
     *
     * @return string
     */
    protected function artisanBinary()
    {
        return defined('ARTISAN_BINARY') ? ARTISAN_BINARY : 'artisan';
    }

/**
     * Listen to the given queue connection.
     *
     * @param  string  $connection
     * @param  string  $queue
     * @param  \Illuminate\Queue\ListenerOptions  $options
     * @return void
     */
    public function listen($connection, $queue, ListenerOptions $options)
    {
        $process = $this->makeProcess($connection, $queue, $options);

while (true) {
            $this->runProcess($process, $options->memory);
        }
    }

/**
     * Create a new Symfony process for the worker.
     *
     * @param  string  $connection
     * @param  string  $queue
     * @param  \Illuminate\Queue\ListenerOptions  $options
     * @return \Symfony\Component\Process\Process
     */
    public function makeProcess($connection, $queue, ListenerOptions $options)
    {
        $command = $this->createCommand(
            $connection,
            $queue,
            $options
        );

// If the environment is set, we will append it to the command array so the
        // workers will run under the specified environment. Otherwise, they will
        // just run under the production environment which is not always right.
        if (isset($options->environment)) {
            $command = $this->addEnvironment($command, $options);
        }

return new Process(
            $command,
            $this->commandPath,
            null,
            null,
            $options->timeout
        );
    }

/**
     * Add the environment option to the given command.
     *
     * @param  array  $command
     * @param  \Illuminate\Queue\ListenerOptions  $options
     * @return array
     */
    protected function addEnvironment($command, ListenerOptions $options)
    {
        return array_merge($command, ["--env={$options->environment}"]);
    }

/**
     * Create the command with the listener options.
     *
     * @param  string  $connection
     * @param  string  $queue
     * @param  \Illuminate\Queue\ListenerOptions  $options
     * @return array
     */
    protected function createCommand($connection, $queue, ListenerOptions $options)
    {
        return array_filter([
            $this->phpBinary(),
            $this->artisanBinary(),
            'queue:work',
            $connection,
            '--once',
            "--name={$options->name}",
            "--queue={$queue}",
            "--backoff={$options->backoff}",
            "--memory={$options->memory}",
            "--sleep={$options->sleep}",
            "--tries={$options->maxTries}",
        ], function ($value) {
            return ! is_null($value);
        });
    }

/**
     * Run the given process.
     *
     * @param  \Symfony\Component\Process\Process  $process
     * @param  int  $memory
     * @return void
     */
    public function runProcess(Process $process, $memory)
    {
        $process->run(function ($type, $line) {
            $this->handleWorkerOutput($type, $line);
        });

// Once we have run the job we'll go check if the memory limit has been exceeded
        // for the script. If it has, we will kill this script so the process manager
        // will restart this with a clean slate of memory automatically on exiting.
        if ($this->memoryExceeded($memory)) {
            $this->stop();
        }
    }

/**
     * Handle output from the worker process.
     *
     * @param  int  $type
     * @param  string  $line
     * @return void
     */
    protected function handleWorkerOutput($type, $line)
    {
        if (isset($this->outputHandler)) {
            call_user_func($this->outputHandler, $type, $line);
        }
    }

/**
     * Determine if the memory limit has been exceeded.
     *
     * @param  int  $memoryLimit
     * @return bool
     */
    public function memoryExceeded($memoryLimit)
    {
        return (memory_get_usage(true) / 1024 / 1024) >= $memoryLimit;
    }

/**
     * Stop listening and bail out of the script.
     *
     * @return void
     */
    public function stop()
    {
        exit;
    }

/**
     * Set the output handler callback.
     *
     * @param  \Closure  $outputHandler
     * @return void
     */
    public function setOutputHandler(Closure $outputHandler)
    {
        $this->outputHandler = $outputHandler;
    }
}

cmd: