PHP QueueManager::connection方法代码示例

 /**
  * 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);
 }