Merge pull request #28 from PHPFastCGI/shutdown

Auto Shutdown

Author: AndrewCarterUK

src/Command/DaemonRunCommand.php

@@ -59,6 +59,7 @@ public function __construct(KernelInterface $kernel, DriverContainerInterface $d
             ->addOption('request-limit', null, InputOption::VALUE_OPTIONAL, 'The maximum number of requests to handle before shutting down')
             ->addOption('memory-limit',  null, InputOption::VALUE_OPTIONAL, 'The memory limit on the daemon instance before shutting down')
             ->addOption('time-limit',    null, InputOption::VALUE_OPTIONAL, 'The time limit on the daemon in seconds before shutting down')
+            ->addOption('auto-shutdown', null, InputOption::VALUE_NONE,     'Perform a graceful shutdown after receiving a 5XX HTTP status code')
             ->addOption('driver',        null, InputOption::VALUE_OPTIONAL, 'The implementation of the FastCGI protocol to use', 'userland');
     }
 
@@ -78,12 +79,14 @@ private function getDaemonOptions(InputInterface $input, OutputInterface $output
         $requestLimit = $input->getOption('request-limit') ?: DaemonOptions::NO_LIMIT;
         $memoryLimit  = $input->getOption('memory-limit')  ?: DaemonOptions::NO_LIMIT;
         $timeLimit    = $input->getOption('time-limit')    ?: DaemonOptions::NO_LIMIT;
+        $autoShutdown = $input->getOption('auto-shutdown');
 
         return new DaemonOptions([
             DaemonOptions::LOGGER        => $logger,
             DaemonOptions::REQUEST_LIMIT => $requestLimit,
             DaemonOptions::MEMORY_LIMIT  => $memoryLimit,
             DaemonOptions::TIME_LIMIT    => $timeLimit,
+            DaemonOptions::AUTO_SHUTDOWN => $autoShutdown,
         ]);
     }
 

src/DaemonInterface.php

@@ -51,6 +51,8 @@ public function run();
     /**
      * Flag the daemon for shutting down. This will stop it from accepting
      * requests.
+     * 
+     * @param string|null Optional message.
      */
-    public function flagShutdown();
+    public function flagShutdown($message = null);
 }

src/DaemonOptions.php

@@ -17,6 +17,7 @@ class DaemonOptions
     const REQUEST_LIMIT = 'request-limit';
     const MEMORY_LIMIT  = 'memory-limit';
     const TIME_LIMIT    = 'time-limit';
+    const AUTO_SHUTDOWN = 'auto-shutdown';
 
     /**
      * @var array
@@ -44,6 +45,7 @@ public function __construct(array $options = [])
             self::REQUEST_LIMIT => self::NO_LIMIT,
             self::MEMORY_LIMIT  => self::NO_LIMIT,
             self::TIME_LIMIT    => self::NO_LIMIT,
+            self::AUTO_SHUTDOWN => false,
         ];
 
         foreach ($options as $option => $value) {

src/DaemonTrait.php

@@ -2,10 +2,7 @@
 
 namespace PHPFastCGI\FastCGIDaemon;
 
-use PHPFastCGI\FastCGIDaemon\Exception\MemoryLimitException;
-use PHPFastCGI\FastCGIDaemon\Exception\RequestLimitException;
 use PHPFastCGI\FastCGIDaemon\Exception\ShutdownException;
-use PHPFastCGI\FastCGIDaemon\Exception\TimeLimitException;
 
 trait DaemonTrait
 {
@@ -14,6 +11,11 @@ trait DaemonTrait
      */
     private $isShutdown = false;
 
+    /**
+     * @var string
+     */
+    private $shutdownMessage = '';
+
     /**
      * @var int
      */
@@ -29,12 +31,20 @@ trait DaemonTrait
      */
     private $memoryLimit;
 
+    /**
+     * @var bool
+     */
+    private $autoShutdown;
+
     /**
      * Flags the daemon for shutting down.
+     * 
+     * @param string $message Optional shutdown message
      */
-    public function flagShutdown()
+    public function flagShutdown($message = null)
     {
         $this->isShutdown = true;
+        $this->shutdownMessage = (null === $message ? 'Daemon flagged for shutdown' : $message);
     }
 
     /**
@@ -48,6 +58,7 @@ private function setupDaemon(DaemonOptions $daemonOptions)
         $this->requestCount = 0;
         $this->requestLimit = $daemonOptions->getOption(DaemonOptions::REQUEST_LIMIT);
         $this->memoryLimit  = $daemonOptions->getOption(DaemonOptions::MEMORY_LIMIT);
+        $this->autoShutdown = $daemonOptions->getOption(DaemonOptions::AUTO_SHUTDOWN);
 
         $timeLimit = $daemonOptions->getOption(DaemonOptions::TIME_LIMIT);
 
@@ -59,13 +70,22 @@ private function setupDaemon(DaemonOptions $daemonOptions)
     }
 
     /**
-     * Increments the request count.
+     * Increments the request count and looks for application errors.
      *
-     * @param int $number The number of requests to increment the count by
+     * @param int[] $statusCodes The status codes of sent responses
      */
-    private function incrementRequestCount($number)
+    private function considerStatusCodes($statusCodes)
     {
-        $this->requestCount += $number;
+        $this->requestCount += count($statusCodes);
+
+        if ($this->autoShutdown) {
+            foreach ($statusCodes as $statusCode) {
+                if ($statusCode >= 500 && $statusCode < 600) {
+                    $this->flagShutdown('Automatic shutdown following status code: ' . $statusCode);
+                    break;
+                }
+            }
+        }
     }
 
     /**
@@ -83,7 +103,7 @@ private function installSignalHandlers()
         });
 
         pcntl_signal(SIGALRM, function () {
-            throw new TimeLimitException('Daemon time limit reached (received SIGALRM)');
+            throw new ShutdownException('Daemon time limit reached (received SIGALRM)');
         });
     }
 
@@ -97,22 +117,22 @@ private function installSignalHandlers()
     private function checkDaemonLimits()
     {
         if ($this->isShutdown) {
-            throw new ShutdownException('Daemon flagged for shutdown');
+            throw new ShutdownException($this->shutdownMessage);
         }
 
         pcntl_signal_dispatch();
 
         if (DaemonOptions::NO_LIMIT !== $this->requestLimit) {
             if ($this->requestLimit <= $this->requestCount) {
-                throw new RequestLimitException('Daemon request limit reached ('.$this->requestCount.' of '.$this->requestLimit.')');
+                throw new ShutdownException('Daemon request limit reached ('.$this->requestCount.' of '.$this->requestLimit.')');
             }
         }
 
         if (DaemonOptions::NO_LIMIT !== $this->memoryLimit) {
             $memoryUsage = memory_get_usage(true);
 
             if ($this->memoryLimit <= $memoryUsage) {
-                throw new MemoryLimitException('Daemon memory limit reached ('.$memoryUsage.' of '.$this->memoryLimit.' bytes)');
+                throw new ShutdownException('Daemon memory limit reached ('.$memoryUsage.' of '.$this->memoryLimit.' bytes)');
             }
         }
     }

src/Driver/Userland/ConnectionHandler/ConnectionHandler.php

@@ -85,13 +85,17 @@ public function ready()
             $this->buffer       .= $data;
             $this->bufferLength += $dataLength;
 
-            $dispatchedRequests = 0;
+            $statusCodes = [];
 
             while (null !== ($record = $this->readRecord())) {
-                $dispatchedRequests += $this->processRecord($record);
+                $statusCode = $this->processRecord($record);
+
+                if (null != $statusCode) {
+                    $statusCodes[] = $statusCode;
+                }
             }
 
-            return $dispatchedRequests;
+            return $statusCodes;
         } catch (\Exception $exception) {
             $this->close();
 
@@ -198,17 +202,16 @@ private function processRecord(array $record)
             if (null !== $content) {
                 fwrite($this->requests[$requestId]['stdin'], $content);
             } else {
-                $this->dispatchRequest($requestId);
-
-                return 1; // One request was dispatched
+                // Returns the status code
+                return $this->dispatchRequest($requestId);
             }
         } elseif (DaemonInterface::FCGI_ABORT_REQUEST === $record['type']) {
             $this->endRequest($requestId);
         } else {
             throw new ProtocolException('Unexpected packet of type: '.$record['type']);
         }
 
-        return 0; // Zero requests were dispatched
+        return null; // No status code to return
     }
 
     /**
@@ -345,7 +348,7 @@ private function writeRecord($requestId, $type, $content = null)
      * Write a response to the connection as FCGI_STDOUT records.
      *
      * @param int             $requestId  The request id to write to
-     * @param string          $headerData The header data to write (including terminating CRLFCRLF)
+     * @param string          $headerData The header -data to write (including terminating CRLFCRLF)
      * @param StreamInterface $stream     The stream to write
      */
     private function writeResponse($requestId, $headerData, StreamInterface $stream)
@@ -399,6 +402,9 @@ private function dispatchRequest($requestId)
         }
 
         $this->endRequest($requestId);
+
+        // This method exists on PSR-7 and Symfony responses
+        return $response->getStatusCode();
     }
 
     /**

src/Driver/Userland/ConnectionHandler/ConnectionHandlerInterface.php

@@ -14,7 +14,7 @@ interface ConnectionHandlerInterface
      * Triggered when the connection the handler was assigned to is ready to
      * be read.
      *
-     * @return int The number of requests dispatched during the function call
+     * @return int[] The status codes of requests dispatched during the function call
      */
     public function ready();
 

src/Driver/Userland/UserlandDaemon.php

@@ -103,8 +103,8 @@ private function processConnectionPool()
             }
 
             try {
-                $dispatchedRequests = $this->connectionHandlers[$id]->ready();
-                $this->incrementRequestCount($dispatchedRequests);
+                $statusCodes = $this->connectionHandlers[$id]->ready();
+                $this->considerStatusCodes($statusCodes);
             } catch (UserlandDaemonException $exception) {
                 $this->daemonOptions->getOption(DaemonOptions::LOGGER)->error($exception->getMessage());
             }