Merge pull request #16 from PHPFastCGI/v0.7-refactor

v0.7 Branch

Author: AndrewCarterUK

src/ApplicationFactory.php

@@ -3,25 +3,28 @@
 namespace PHPFastCGI\FastCGIDaemon;
 
 use PHPFastCGI\FastCGIDaemon\Command\DaemonRunCommand;
+use PHPFastCGI\FastCGIDaemon\Driver\DriverContainer;
+use PHPFastCGI\FastCGIDaemon\Driver\DriverContainerInterface;
 use Symfony\Component\Console\Application;
+
 /**
  * The default implementation of the ApplicationFactoryInterface.
  */
 class ApplicationFactory implements ApplicationFactoryInterface
 {
     /**
-     * @var DaemonFactoryInterface
+     * @var DriverContainerInterface
      */
-    private $daemonFactory;
+    private $driverContainer;
 
     /**
      * Constructor.
-     * 
-     * @param DaemonFactoryInterface $daemonFactory The factory to use to create daemons
+     *
+     * @param DriverContainerInterface $driverContainer The driver container
      */
-    public function __construct(DaemonFactoryInterface $daemonFactory = null)
+    public function __construct(DriverContainerInterface $driverContainer = null)
     {
-        $this->daemonFactory = $daemonFactory;
+        $this->driverContainer = $driverContainer ?: new DriverContainer();
     }
 
     /**
@@ -31,7 +34,7 @@ public function createApplication($kernel, $commandName = null, $commandDescript
     {
         $command = $this->createCommand($kernel, $commandName, $commandDescription);
 
-        $application = new Application;
+        $application = new Application();
         $application->add($command);
 
         return $application;
@@ -42,6 +45,29 @@ public function createApplication($kernel, $commandName = null, $commandDescript
      */
     public function createCommand($kernel, $commandName = null, $commandDescription = null)
     {
-        return new DaemonRunCommand($kernel, $this->daemonFactory, $commandName, $commandDescription);
+        $kernelObject = $this->getKernelObject($kernel);
+
+        return new DaemonRunCommand($kernelObject, $this->driverContainer, $commandName, $commandDescription);
+    }
+
+    /**
+     * Converts the kernel parameter to an object implementing the KernelInterface
+     * if it is a callable.
+     *
+     * Otherwise returns the object directly.
+     *
+     * @param KernelInterface|callable $kernel The kernel
+     *
+     * @return KernelInterface The kernel as an object implementing the KernelInterface
+     */
+    private function getKernelObject($kernel)
+    {
+        if ($kernel instanceof KernelInterface) {
+            return $kernel;
+        } elseif (is_callable($kernel)) {
+            return new CallbackWrapper($kernel);
+        }
+
+        throw new \InvalidArgumentException('Kernel must be callable or an instance of KernelInterface');
     }
 }

src/ApplicationFactoryInterface.php

@@ -12,7 +12,7 @@
 interface ApplicationFactoryInterface
 {
     /**
-     * Create a Symfony console application
+     * Create a Symfony console application.
      *
      * @param KernelInterface|callable $kernel             The kernel to use
      * @param string                   $commandName        The name of the daemon run command
@@ -23,7 +23,7 @@ interface ApplicationFactoryInterface
     public function createApplication($kernel, $commandName = null, $commandDescription = null);
 
     /**
-     * Create a Symfony console command
+     * Create a Symfony console command.
      *
      * @param KernelInterface|callable $kernel             The kernel to use
      * @param string                   $commandName        The name of the daemon run command

src/Command/DaemonRunCommand.php

@@ -2,8 +2,8 @@
 
 namespace PHPFastCGI\FastCGIDaemon\Command;
 
-use PHPFastCGI\FastCGIDaemon\DaemonFactory;
-use PHPFastCGI\FastCGIDaemon\DaemonFactoryInterface;
+use PHPFastCGI\FastCGIDaemon\DaemonOptions;
+use PHPFastCGI\FastCGIDaemon\Driver\DriverContainerInterface;
 use PHPFastCGI\FastCGIDaemon\KernelInterface;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
@@ -17,43 +17,61 @@ class DaemonRunCommand extends Command
     const DEFAULT_DESCRIPTION = 'Run the FastCGI daemon';
 
     /**
-     * @var DaemonFactoryInterface
+     * @var KernelInterface
      */
-    private $daemonFactory;
+    private $kernel;
 
     /**
-     * @var KernelInterface|callable
+     * @var DriverContainerInterface
      */
-    private $kernel;
+    private $driverContainer;
 
     /**
      * Constructor.
      *
-     * @param KernelInterface|callable $kernel        The kernel to be given to the daemon
-     * @param DaemonFactoryInterface   $daemonFactory The factory to use to create the daemon
-     * @param string                   $name          The name of the daemon run command
-     * @param string                   $description   The description of the daemon run command
+     * @param KernelInterface          $kernel          The kernel to be given to the daemon
+     * @param DriverContainerInterface $driverContainer The driver container
+     * @param string                   $name            The name of the daemon run command
+     * @param string                   $description     The description of the daemon run command
      */
-    public function __construct($kernel, DaemonFactoryInterface $daemonFactory = null, $name = null, $description = null)
+    public function __construct(KernelInterface $kernel, DriverContainerInterface $driverContainer, $name = null, $description = null)
     {
-        $daemonFactory = $daemonFactory ?: new DaemonFactory;
-        $name          = $name          ?: self::DEFAULT_NAME;
-        $description   = $description   ?: self::DEFAULT_DESCRIPTION;
+        $this->kernel          = $kernel;
+        $this->driverContainer = $driverContainer;
+
+        $name        = $name        ?: self::DEFAULT_NAME;
+        $description = $description ?: self::DEFAULT_DESCRIPTION;
 
         parent::__construct($name);
 
         $this
             ->setDescription($description)
-            ->addOption('port', null, InputOption::VALUE_OPTIONAL, 'TCP port to listen on (if not present, daemon will listen on FCGI_LISTENSOCK_FILENO)')
-            ->addOption('host', null, InputOption::VALUE_OPTIONAL, 'TCP host to listen on');
+            ->addOption('port',          null, InputOption::VALUE_OPTIONAL, 'TCP port to listen on (if not present, daemon will listen on FCGI_LISTENSOCK_FILENO)')
+            ->addOption('host',          null, InputOption::VALUE_OPTIONAL, 'TCP host to listen on')
+            ->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('driver',        null, InputOption::VALUE_OPTIONAL, 'The implementation of the FastCGI protocol to use', 'userland');
+    }
 
-        $this->daemonFactory = $daemonFactory;
+    /**
+     * Retrieves the daemon configuration from the Symfony command input and
+     * output objects.
+     *
+     * @param InputInterface  $input  The  Symfony command input
+     * @param OutputInterface $output The Symfony command output
+     *
+     * @return DaemonOptions The daemon configuration
+     */
+    private function getDaemonOptions(InputInterface $input, OutputInterface $output)
+    {
+        $logger = new ConsoleLogger($output);
 
-        if (!$kernel instanceof KernelInterface && !is_callable($kernel)) {
-            throw new \InvalidArgumentException('Kernel parameter must be an instance of KernelInterface or a callable');
-        }
+        $requestLimit = $input->getOption('request-limit') ?: DaemonOptions::NO_LIMIT;
+        $memoryLimit  = $input->getOption('memory-limit')  ?: DaemonOptions::NO_LIMIT;
+        $timeLimit    = $input->getOption('time-limit')    ?: DaemonOptions::NO_LIMIT;
 
-        $this->kernel = $kernel;
+        return new DaemonOptions($logger, $requestLimit, $memoryLimit, $timeLimit);
     }
 
     /**
@@ -64,24 +82,22 @@ protected function execute(InputInterface $input, OutputInterface $output)
         $port = $input->getOption('port');
         $host = $input->getOption('host');
 
+        $daemonOptions = $this->getDaemonOptions($input, $output);
+
+        $driver        = $input->getOption('driver');
+        $daemonFactory = $this->driverContainer->getFactory($driver);
+
         if (null !== $port) {
             // If we have the port, create a TCP daemon
-
-            if (null !== $host) {
-                $daemon = $this->daemonFactory->createTcpDaemon($this->kernel, $port, $host);
-            } else {
-                $daemon = $this->daemonFactory->createTcpDaemon($this->kernel, $port);
-            }
+            $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 = $this->daemonFactory->createDaemon($this->kernel);
+            $daemon = $daemonFactory->createDaemon($this->kernel, $daemonOptions);
         }
 
-        $daemon->setLogger(new ConsoleLogger($output));
-
         $daemon->run();
     }
 }