Merge pull request #27 from PHPFastCGI/shutdown

Added flag shutdown functionality

Author: AndrewCarterUK

src/Command/DaemonRunCommand.php

@@ -27,6 +27,11 @@ class DaemonRunCommand extends Command
      */
     private $driverContainer;
 
+    /**
+     * @var DaemonInterface
+     */
+    private $daemon;
+
     /**
      * Constructor.
      *
@@ -39,6 +44,7 @@ public function __construct(KernelInterface $kernel, DriverContainerInterface $d
     {
         $this->kernel          = $kernel;
         $this->driverContainer = $driverContainer;
+        $this->daemon          = null;
 
         $name        = $name        ?: self::DEFAULT_NAME;
         $description = $description ?: self::DEFAULT_DESCRIPTION;
@@ -97,15 +103,27 @@ protected function execute(InputInterface $input, OutputInterface $output)
 
         if (null !== $port) {
             // If we have the port, create a TCP daemon
-            $daemon = $daemonFactory->createTcpDaemon($this->kernel, $daemonOptions, $host ?: 'localhost', $port);
+            $this->daemon = $daemonFactory->createTcpDaemon($this->kernel, $daemonOptions, $host ?: 'localhost', $port);
         } elseif (null !== $host) {
             // If we have the host but not the port, we cant create a TCP daemon - throw exception
             throw new \InvalidArgumentException('TCP port option must be set if host option is set');
         } else {
             // With no host or port, listen on FCGI_LISTENSOCK_FILENO (default)
-            $daemon = $daemonFactory->createDaemon($this->kernel, $daemonOptions, $fd);
+            $this->daemon = $daemonFactory->createDaemon($this->kernel, $daemonOptions, $fd);
+        }
+
+        $this->daemon->run();
+    }
+
+    /**
+     * Flag the daemon for shutdown.
+     */
+    public function flagShutdown()
+    {
+        if (null === $this->daemon) {
+            throw new \RuntimeException('There is no daemon running');
         }
 
-        $daemon->run();
+        $this->daemon->flagShutdown();
     }
 }

src/DaemonInterface.php

@@ -47,4 +47,10 @@ interface DaemonInterface
      * @throws \Exception On fatal error
      */
     public function run();
+
+    /**
+     * Flag the daemon for shutting down. This will stop it from accepting
+     * requests.
+     */
+    public function flagShutdown();
 }

src/DaemonTrait.php

@@ -9,6 +9,11 @@
 
 trait DaemonTrait
 {
+    /**
+     * @var bool
+     */
+    private $isShutdown = false;
+
     /**
      * @var int
      */
@@ -24,6 +29,14 @@ trait DaemonTrait
      */
     private $memoryLimit;
 
+    /**
+     * Flags the daemon for shutting down.
+     */
+    public function flagShutdown()
+    {
+        $this->isShutdown = true;
+    }
+
     /**
      * Loads to configuration from the daemon options and installs signal
      * handlers.
@@ -76,12 +89,17 @@ private function installSignalHandlers()
 
     /**
      * Checks the current PHP process against the limits specified in a daemon
-     * options object.
+     * options object. This function will also throw an exception if the daemon
+     * has been flagged for shutdown.
      *
      * @throws ShutdownException When limits in the daemon options are exceeded
      */
     private function checkDaemonLimits()
     {
+        if ($this->isShutdown) {
+            throw new ShutdownException('Daemon flagged for shutdown');
+        }
+
         pcntl_signal_dispatch();
 
         if (DaemonOptions::NO_LIMIT !== $this->requestLimit) {

src/Exception/ShutdownException.php

@@ -8,6 +8,6 @@
  * They may be triggered by a SIGINT or by exceeding limits specified in the
  * daemon configuration (such as memory and request limits).
  */
-class ShutdownException extends \RuntimeException
+class ShutdownException extends DaemonException
 {
 }

test/Command/DaemonRunCommandTest.php

@@ -129,6 +129,35 @@ public function testPortOptionOnly()
         $this->assertEquals('getFactory',      $context['driverContainer']->getDelegatedCalls()[0][0]);
     }
 
+    /**
+     * Test flag shutdown.
+     */
+    public function testShutdown()
+    {
+        $expectations = ['driver' => 'userland'];
+
+        $context = $this->createTestingContext($expectations);
+
+        $context['command']->run(new ArrayInput([]), new NullOutput());
+        $context['command']->flagShutdown();
+
+        $this->assertEquals('run',          $context['daemon']->getDelegatedCalls()[0][0]);
+        $this->assertEquals('flagShutdown', $context['daemon']->getDelegatedCalls()[1][0]);
+        $this->assertEquals('createDaemon', $context['daemonFactory']->getDelegatedCalls()[0][0]);
+        $this->assertEquals('getFactory',   $context['driverContainer']->getDelegatedCalls()[0][0]);
+    }
+
+    /**
+     * Test flag shutdown with no daemon.
+     * 
+     * @expectedException \RuntimeException
+     */
+    public function testShutdownNoDaemon()
+    {
+        $command = new DaemonRunCommand(new MockKernel(), new MockDriverContainer());
+        $command->flagShutdown();
+    }
+
     /**
      * Construct mock objects set to test for expected values of different
      * parameters when specified.
@@ -146,7 +175,7 @@ private function createTestingContext(array $expectations)
         };
 
         $mockKernel = new MockKernel();
-        $mockDaemon = new MockDaemon(['run' => false]);
+        $mockDaemon = new MockDaemon(['run' => false, 'flagShutdown' => false]);
 
         $mockDaemonFactory = new MockDaemonFactory([
             'createTcpDaemon' => function ($kernel, $options, $host, $port) use ($assertExpected, $mockKernel, $mockDaemon) {

test/Driver/Userland/UserlandDaemonTest.php

@@ -19,7 +19,21 @@
 class UserlandDaemonTest extends \PHPUnit_Framework_TestCase
 {
     /**
-     * Tests that the daemon shuts down after reaching its request .
+     * Tests that the daemon shuts down after being flagged for shutdown.
+     */
+    public function testFlagShutdown()
+    {
+        // Set a memory limit to make sure that it isn't breached (added 10MB on top of peak usage)
+        $context = $this->createTestingContext(1, memory_get_peak_usage() + (10 * 1024 * 1024));
+
+        $context['daemon']->flagShutdown();
+        $context['daemon']->run();
+
+        $this->assertEquals('Daemon flagged for shutdown', $context['logger']->getMessages()[0]['message']);
+    }
+
+    /**
+     * Tests that the daemon shuts down after reaching its request.
      */
     public function testRequestLimit()
     {

test/Helper/Mocker/MockDaemon.php

@@ -12,4 +12,9 @@ public function run()
     {
         return $this->delegateCall('run', func_get_args());
     }
+
+    public function flagShutdown()
+    {
+        return $this->delegateCall('flagShutdown', func_get_args());
+    }
 }