/**
* Pushes a job into a specific queue connection.
*
* If you are using multiple SQS queues, this method might be useful.
* Instead of having to provide the whole queue URL every time you want to
* push a job into it, you just provide the name of the queue connection
* as set in the configuration file.
*
* @param mixed $job
* @param array $data
* @param string $connection Name of the connection
* @param string $queue
*
* @return mixed
*/
public function push($job, array $data, $connection = null, $queue = null)
{
if ($connection == null) {
return $this->manager->push($job, $data, $queue);
}
$connection = $this->manager->connection($connection);
return $connection->push($job, $data, $queue);
}
/**
* {@inheritDoc}
*/
public function clear($connection, $queue)
{
$count = 0;
$connection = $this->manager->connection($connection);
while ($job = $connection->pop($queue)) {
$job->delete();
$count++;
}
return $count;
}
/**
* Listen to the given queue.
*
* @param string $connectionName
* @param string $queue
* @param int $delay
* @param int $memory
* @param int $sleep
* @param int $maxTries
* @return void
*/
public function pop($connectionName, $queue = null, $delay = 0, $memory = 128, $sleep = 3, $maxTries = 0)
{
$connection = $this->manager->connection($connectionName);
$job = $this->getNextJob($connection, $queue);
// If we're able to pull a job off of the stack, we will process it and
// then make sure we are not exceeding our memory limits for the run
// which is to protect against run-away memory leakages from here.
if (!is_null($job)) {
$this->process($this->manager->getName($connectionName), $job, $maxTries, $delay);
} else {
$this->sleep($sleep);
}
}
/**
* {@inheritdoc}
*/
public function send($data)
{
$this->eventId = array_get($data, 'event_id');
// send error now if queue not set
if (is_null($this->queue)) {
return $this->sendError($data);
}
// put the job into the queue
// Sync connection will sent directly
// if failed to add job to queue send it now
try {
$this->queue->connection(array_get($this->config, 'queue.connection'))->push(Job::class, $data, array_get($this->config, 'queue.name'));
} catch (Exception $e) {
return $this->sendError($data);
}
return;
}
/**
* Process the next job on the queue.
*
* @param string $connectionName
* @param string $queue
* @param \Illuminate\Queue\WorkerOptions $options
* @return void
*/
public function runNextJob($connectionName, $queue, WorkerOptions $options)
{
$job = $this->getNextJob($this->manager->connection($connectionName), $queue);
// If we're able to pull a job off of the stack, we will process it and then return
// from this method. If there is no job on the queue, we will "sleep" the worker
// for the specified number of seconds, then keep processing jobs after sleep.
if ($job) {
return $this->runJob($job, $connectionName, $options);
}
$this->sleep($options->sleep);
}
/**
* Listen to the given queue.
*
* @param string $connectionName
* @param string $queue
* @param int $delay
* @param int $sleep
* @param int $maxTries
* @return array
*/
public function pop($connectionName, $queue = null, $delay = 0, $sleep = 3, $maxTries = 0)
{
$connection = $this->manager->connection($connectionName);
$job = $this->getNextJob($connection, $queue);
// If we're able to pull a job off of the stack, we will process it and
// then immediately return back out. If there is no job on the queue
// we will "sleep" the worker for the specified number of seconds.
if (!is_null($job)) {
return $this->process($this->manager->getName($connectionName), $job, $maxTries, $delay);
}
$this->sleep($sleep);
return ['job' => null, 'failed' => false];
}
/**
* Process the next job on the queue.
*
* @param string $connectionName
* @param string $queue
* @param \Illuminate\Queue\WorkerOptions $options
* @return void
*/
public function runNextJob($connectionName, $queue, WorkerOptions $options)
{
try {
$job = $this->getNextJob($this->manager->connection($connectionName), $queue);
// If we're able to pull a job off of the stack, we will process it and then return
// from this method. If there is no job on the queue, we will "sleep" the worker
// for the specified number of seconds, then keep processing jobs after sleep.
if ($job) {
return $this->process($connectionName, $job, $options);
}
} catch (Exception $e) {
$this->exceptions->report($e);
} catch (Throwable $e) {
$this->exceptions->report(new FatalThrowableError($e));
}
$this->sleep($options->sleep);
}
/**
* Process the next job on the queue.
*
* @param string $connectionName
* @param string $queue
* @param int $delay
* @param int $sleep
* @param int $maxTries
* @return void
*/
public function runNextJob($connectionName, $queue = null, $delay = 0, $sleep = 3, $maxTries = 0)
{
try {
$connection = $this->manager->connection($connectionName);
$job = $this->getNextJob($connection, $queue);
// If we're able to pull a job off of the stack, we will process it and then return
// from this method. If there is no job on the queue, we will "sleep" the worker
// for the specified number of seconds, then keep processing jobs after sleep.
if (!is_null($job)) {
return $this->process($this->manager->getName($connectionName), $job, $maxTries, $delay);
}
} catch (Exception $e) {
if ($this->exceptions) {
$this->exceptions->report($e);
}
}
$this->sleep($sleep);
}
/**
* Resolve a queue connection instance.
*
* @param string $name
* @return \Illuminate\Contracts\Queue\Queue
* @static
*/
public static function connection($name = null)
{
return \Illuminate\Queue\QueueManager::connection($name);
}
/**
* Get a registered connection instance.
*
* @param string $name
* @return \Illuminate\Contracts\Queue\Queue
*/
public function getConnection($name = null)
{
return $this->manager->connection($name);
}
/**
* Establish a queue connection.
*
* @param array $config
* @return \Illuminate\Contracts\Queue\Queue
*/
public function connect(array $config)
{
$shortTermQueue = $this->queueManager->connection($config['short-term-queue']);
$longTermQueue = $this->queueManager->connection($config['long-term-queue']);
return new HybridQueue($shortTermQueue, $longTermQueue, $config['short-term-queue'], $config['threshold']);
}
/**
* @param array $config
* @return \Illuminate\Queue\QueueInterface
*/
public function connect(array $config)
{
return new ProxyQueue($this->manager->connection($config['connection']));
}
public function handle(QueueManager $queueManager)
{
$queueManager->connection($this->connection)->later($this->delay, $this->job, $this->data, $this->queue);
}
