PHP Queue\QueueManager类代码示例

 /**
  * @param  \Illuminate\Queue\QueueManager  $manager
  * @return void
  */
 protected function registerSortedRedisConnector($manager)
 {
     $app = $this->app;
     $manager->addConnector("sorted-redis", function () use($app) {
         return new SortedRedisConnector($app["redis"]);
     });
 }

 /**
  * Register the Redis queue connector.
  *
  * @param  \Illuminate\Queue\QueueManager  $manager
  * @return void
  */
 protected function registerRedisConnector($manager)
 {
     $app = $this->app;
     $manager->extend('redis', function () use($app) {
         return new RedisConnector($app['redis']);
     });
 }

 /**
  * Register the GAE queue connector.
  *
  * @param  \Illuminate\Queue\QueueManager  $manager
  * @return void
  */
 protected function registerGaeConnector($manager)
 {
     $app = $this->app;
     $manager->addConnector('gae', function () use($app) {
         return new GaeConnector($app['encrypter'], $app['request']);
     });
 }

 /**
  * Register the Resque queue connector.
  *
  * @param \Illuminate\Queue\QueueManager $manager
  * @return void
  */
 protected function registerResqueConnector($manager)
 {
     $manager->addConnector('resque', function () {
         $config = Config::get('database.redis.default');
         Config::set('queue.connections.resque', array_merge($config, ['driver' => 'resque']));
         return new ResqueConnector();
     });
 }

 /**
  * Register the Resque queue connector.
  *
  * @param  \Illuminate\Queue\QueueManager  $manager
  * @return void
  */
 protected function registerResqueConnector($manager)
 {
     $connections = Config::get('queue.connections', []);
     foreach ($connections as $connection) {
         if ($connection['driver'] !== 'resque') {
             $manager->addConnector($connection['driver'], function () {
                 return new ResqueConnector();
             });
         }
     }
     $manager->addConnector('resque', function () {
         $config = Config::get('database.redis.default');
         Config::set('queue.connections.resque', array_merge($config, ['driver' => 'resque']));
         return new ResqueConnector();
     });
 }

 /**
  * Register the IronMQ queue connector.
  *
  * @param  \Illuminate\Queue\QueueManager  $manager
  * @return void
  */
 protected function registerIronConnector($manager)
 {
     $app = $this->app;
     $manager->addConnector('iron', function () use($app) {
         return new IronConnector($app['encrypter'], $app['request']);
     });
     $this->registerIronRequestBinder();
 }

 /**
  * {@inheritdoc}
  *
  * @throws \RuntimeException Thrown if the queue has not been set.
  */
 public function process($url, $data, array $headers = [])
 {
     if (empty($this->queue)) {
         throw new RuntimeException('Queue not set');
     }
     $data = ['url' => $url, 'data' => $data, 'headers' => $headers, 'transport' => $this->transport->toArray()];
     $this->queue->push('rcrowe\\Raven\\Handler\\Laravel\\Job', $data);
 }

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

 /**
  * Handle the event.
  *
  * @param  VoteWasOpened $event
  * @return void
  */
 public function handle(VoteWasOpened $event)
 {
     /**
      * Queue OpenVoteCommand
      */
     $command = new CloseVotingCommand($event->vote);
     $delay = $event->vote->close_date->timestamp - $this->carbon->now()->timestamp;
     $this->queue->laterOn('voting', $delay, $command);
 }

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

 /**
  * Queue a new e-mail message for sending after (n) seconds.
  *
  * @param  int  $delay
  * @param  string  $queue
  * @return void
  */
 public function later($delay, $queue = null)
 {
     if ($this->queueManager) {
         $swiftMessage = $this->message->getSwiftMessage();
         $this->queueManager->later($delay, new SendEmailJob($swiftMessage), $queue);
     }
 }

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

 /**
  * Installs dependencies.
  *
  * @return boolean
  */
 public function install()
 {
     if (!$this->isInstalling()) {
         $this->queue->push(ComposerInstallJob::class);
         return true;
     } else {
         return 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)
 {
     $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);
 }