Update bootstrap script to create an appropriate reserver based off the environment.

Author: rayward

bin/resque

@@ -25,6 +25,9 @@ if (!class_exists('Composer\Autoload\ClassLoader', false)) {
     );
 }
 
+use Resque\Reserver\ReserverFactory;
+use Resque\Reserver\UnknownReserverException;
+
 $QUEUE = getenv('QUEUE');
 if(empty($QUEUE)) {
     die("Set QUEUE env var containing the list of queues to work.\n");
@@ -73,7 +76,22 @@ if (!isset($logger) || !is_object($logger)) {
     $logger = new Resque_Log($logLevel);
 }
 
-$BLOCKING = getenv('BLOCKING') !== FALSE;
+$reserverFactory = new ReserverFactory($logger);
+Resque_Worker::setReserverFactory($reserverFactory);
+
+$queues = explode(',', $QUEUE);
+if (!is_array($queues)) {
+    $queues = array($queues);
+}
+
+$reserver = null;
+try {
+    $reserver = $reserverFactory->createReserverFromEnvironment($queues);
+} catch (UnknownReserverException $exception) {
+    $logger->emergency("Could not create reserver: {error}", ['error' => $exception->getMessage()]);
+    die;
+}
+
 
 $interval = 5;
 $INTERVAL = getenv('INTERVAL');
@@ -102,19 +120,17 @@ if($count > 1) {
         }
         // Child, start the worker
         else if(!$pid) {
-            $queues = explode(',', $QUEUE);
-            $worker = new Resque_Worker($queues);
+            $worker = new Resque_Worker($reserver, $queues);
             $worker->setLogger($logger);
             $logger->log(Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', array('worker' => $worker));
-            $worker->work($interval, $BLOCKING);
+            $worker->work($interval);
             break;
         }
     }
 }
 // Start a single worker
 else {
-    $queues = explode(',', $QUEUE);
-    $worker = new Resque_Worker($queues);
+    $worker = new Resque_Worker($reserver, $queues);
     $worker->setLogger($logger);
 
     $PIDFILE = getenv('PIDFILE');
@@ -124,6 +140,5 @@ else {
     }
 
     $logger->log(Psr\Log\LogLevel::NOTICE, 'Starting worker {worker}', array('worker' => $worker));
-    $worker->work($interval, $BLOCKING);
+    $worker->work($interval);
 }
-?>

lib/Resque/Reserver/ReserverFactory.php

@@ -43,6 +43,32 @@ public function createReserverFromName($name, array $queues)
         return $this->$methodName($queues);
     }
 
+    /**
+     * Creates a reserver based off the environment configuration.
+     *
+     * The following environment vars are checked (in this order):
+     * - BLOCKING: Creates a BlockingListPopReserver (any non empty value)
+     * - RESERVER: Creates a reserver specified in snake case format without the reserver suffix, eg. 'random_queue_order'
+     *
+     * If neither var is specified, the default resever (QueueOrderReserver) is created.
+     *
+     * @param array $queues
+     * @return ReserverInterface
+     * @throws UnknownReserverException If the reserver specified in RESERVER could not be found.
+     */
+    public function createReserverFromEnvironment(array $queues)
+    {
+        if (!empty(getenv('BLOCKING'))) {
+            $reserver = $this->createBlockingListPopReserver($queues);
+        } elseif (getenv('RESERVER') !== false) {
+            $reserver = $this->createReserverFromName((string)getenv('RESERVER'), $queues);
+        } else {
+            $reserver = $this->createDefaultReserver($queues);
+        }
+
+        return $reserver;
+    }
+
     /**
      * Creates the default reserver.
      *

test/Resque/Tests/Reserver/ReserverFactoryTest.php

@@ -57,4 +57,55 @@ public function testCreateDefaultReserverCreatesExpectedReserver()
         $reserver = $this->getFactory()->createDefaultReserver(array());
         $this->assertInstanceOf('\Resque\Reserver\QueueOrderReserver', $reserver);
     }
+
+    public function createReserverFromEnvironmentDataProvider()
+    {
+        return array(
+            array(array('BLOCKING=1'), '\Resque\Reserver\BlockingListPopReserver'),
+            array(array('BLOCKING=0', 'RESERVER=random_queue_order'), '\Resque\Reserver\RandomQueueOrderReserver'),
+            array(array('BLOCKING=', 'RESERVER=random_queue_order'), '\Resque\Reserver\RandomQueueOrderReserver'),
+            array(array('RESERVER=Queue_Order'), '\Resque\Reserver\QueueOrderReserver'),
+            array(array(), '\Resque\Reserver\QueueOrderReserver'),
+        );
+    }
+
+    /**
+     * @dataProvider createReserverFromEnvironmentDataProvider
+     */
+    public function testCreateReserverFromEnvironmentCreatesExpectedReserver($env, $expectedReserver)
+    {
+        $queues = array(
+            'queue_a',
+            'queue_b',
+            'queue_c',
+            'queue_d',
+        );
+
+        foreach ($env as $var) {
+            putenv($var);
+        }
+
+        $reserver = $this->getFactory()->createReserverFromEnvironment($queues);
+        $this->assertInstanceOf($expectedReserver, $reserver);
+
+        // account for shuffling by RandomQueueOrderReserver
+        $actualQueues = $reserver->getQueues();
+        sort($actualQueues);
+
+        $this->assertEquals($queues, $actualQueues);
+
+        putenv('BLOCKING');
+        putenv('RESERVER');
+    }
+
+    /**
+     * @expectedException Resque\Reserver\UnknownReserverException
+     * @expectedExceptionMessage Unknown reserver 'foobar'
+     */
+    public function testCreateReserverFromEnvironmentThrowsExceptionForUnknownReserver()
+    {
+        putenv('RESERVER=foobar');
+        $this->getFactory()->createReserverFromEnvironment(array());
+        putenv('RESERVER');
+    }
 }