Feature/builder dependency (#16)

* Add CommandDispatcherInterface

This interface beside CommandInterface is used to dewire the hard
dependency on symfony processbuilder inside SystemCtl

This way testing and mocking the desired result should be alot easier

Resolve #15

Author: icanhazstring

Vagrantfile

@@ -4,6 +4,9 @@ Vagrant.configure("2") do |config|
   config.vm.provision "shell", inline: <<-SHELL
     add-apt-repository ppa:ondrej/php
     apt-get update
-    apt-get install -y php7.1 php7.1-xml php7.1-mbstring php7.1-zip composer
+    apt-get install -y php7.1 php7.1-xml php7.1-mbstring php7.1-zip php7.1-curl php7.1-xdebug composer
+
+    # Switch to /vagrant and install packages
+    cd /vagrant && composer install
   SHELL
 end

src/Command/CommandDispatcherInterface.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace SystemCtl\Command;
+
+use SystemCtl\Exception\CommandFailedException;
+
+interface CommandDispatcherInterface
+{
+    /**
+     * Timeout after which the dispatcher failes the execution
+     *
+     * @param int $timeout
+     *
+     * @return CommandDispatcherInterface
+     */
+    public function setTimeout(int $timeout): CommandDispatcherInterface;
+
+    /**
+     * Set basic binary to dispatch
+     *
+     * @param string $binary
+     *
+     * @return CommandDispatcherInterface
+     */
+    public function setBinary(string $binary): CommandDispatcherInterface;
+
+    /**
+     * Dispatch given commands against implementers logic and creating a new command
+     * to read results
+     *
+     * @param array $commands
+     *
+     * @return CommandInterface
+     * @throws CommandFailedException
+     */
+    public function dispatch(...$commands): CommandInterface;
+}

src/Command/CommandInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+
+namespace SystemCtl\Command;
+
+use SystemCtl\Exception\CommandFailedException;
+
+/**
+ * Interface CommandInterface
+ *
+ * @package SystemCtl\Command
+ * @author icanhazstring <[email protected]>
+ */
+interface CommandInterface
+{
+    /**
+     * @return CommandInterface
+     * @throws CommandFailedException
+     */
+    public function run(): CommandInterface;
+
+    /**
+     * @return string
+     */
+    public function getOutput(): string;
+
+    /**
+     * @return bool
+     */
+    public function isSuccessful(): bool;
+}

src/Command/SymfonyCommand.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace SystemCtl\Command;
+
+use Symfony\Component\Process\Process;
+use SystemCtl\Exception\CommandFailedException;
+
+/**
+ * Class SymfonyCommand
+ *
+ * @package SystemCtl\Command
+ * @author icanhazstring <[email protected]>
+ */
+class SymfonyCommand implements CommandInterface
+{
+    /** @var Process */
+    private $process;
+
+    public function __construct(Process $process)
+    {
+        $this->process = $process;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function getOutput(): string
+    {
+        return $this->process->getOutput();
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function isSuccessful(): bool
+    {
+        return $this->process->isSuccessful();
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function run(): CommandInterface
+    {
+        $this->process->run();
+
+        if (!$this->process->isSuccessful()) {
+            throw new CommandFailedException($this->process->getErrorOutput());
+        }
+
+        return $this;
+    }
+}

src/Command/SymfonyCommandDispatcher.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace SystemCtl\Command;
+
+use Symfony\Component\Process\ProcessBuilder;
+
+/**
+ * Class SymfonyCommandDispatcher
+ *
+ * @package SystemCtl\Command
+ * @author  icanhazstring <[email protected]>
+ */
+class SymfonyCommandDispatcher implements CommandDispatcherInterface
+{
+    private $binary;
+    private $timetout;
+
+    /**
+     * @inheritdoc
+     */
+    public function setBinary(string $binary): CommandDispatcherInterface
+    {
+        $this->binary = $binary;
+
+        return $this;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function setTimeout(int $timeout): CommandDispatcherInterface
+    {
+        $this->timetout = $timeout;
+
+        return $this;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function dispatch(...$commands): CommandInterface
+    {
+        $processBuilder = new ProcessBuilder();
+        $processBuilder->setPrefix($this->binary);
+        $processBuilder->setTimeout($this->timetout);
+        $processBuilder->setArguments($commands);
+
+        $process = new SymfonyCommand($processBuilder->getProcess());
+
+        return $process->run();
+    }
+}

src/Exception/CommandFailedException.php

@@ -4,25 +4,4 @@
 
 class CommandFailedException extends \Exception
 {
-    /**
-     * @param $name
-     * @param $command
-     *
-     * @return CommandFailedException
-     */
-    public static function fromService($name, $command): CommandFailedException
-    {
-        return new self(sprintf('Failed to %s service %s', $command, $name));
-    }
-
-    /**
-     * @param $name
-     * @param $command
-     *
-     * @return CommandFailedException
-     */
-    public static function fromTimer($name, $command): CommandFailedException
-    {
-        return new self(sprintf('Failed to %s timer %s', $command, $name));
-    }
 }

src/SystemCtl.php

@@ -2,7 +2,8 @@
 
 namespace SystemCtl;
 
-use Symfony\Component\Process\ProcessBuilder;
+use SystemCtl\Command\CommandDispatcherInterface;
+use SystemCtl\Command\SymfonyCommandDispatcher;
 use SystemCtl\Exception\UnitTypeNotSupportedException;
 use SystemCtl\Unit\Service;
 use SystemCtl\Unit\Timer;
@@ -35,6 +36,8 @@ class SystemCtl
         Timer::UNIT,
     ];
 
+    private $commandDispatcher;
+
     /**
      * Change systemctl binary
      *
@@ -61,6 +64,7 @@ public static function setTimeout(int $timeout): void
      *
      * @return UnitInterface
      * @throws UnitTypeNotSupportedException
+     * @deprecated This static method is deprecated, please refer to a specifc get method for a unit
      */
     public static function unitFromSuffix(string $unitSuffix, string $unitName): UnitInterface
     {
@@ -70,105 +74,121 @@ public static function unitFromSuffix(string $unitSuffix, string $unitName): Uni
             throw new UnitTypeNotSupportedException('Unit type ' . $unitSuffix . ' not supported');
         }
 
-        return new $unitClass($unitName, new ProcessBuilder([self::$binary]));
+        $commandDispatcher = (new SymfonyCommandDispatcher)
+            ->setTimeout(self::$timeout)
+            ->setBinary(self::$binary);
+
+        return new $unitClass($unitName, $commandDispatcher);
     }
 
     /**
      * List all supported units
      *
      * @param null|string $unitPrefix
-     * @param string[] $unitTypes
+     * @param string[]    $unitTypes
+     *
      * @return array|\string[]
      */
     public function listUnits(?string $unitPrefix = null, array $unitTypes = self::SUPPORTED_UNITS): array
     {
-        $processBuilder = $this->getProcessBuilder()
-            ->add('list-units');
+        $commands = ['list-units'];
 
         if ($unitPrefix) {
-            $processBuilder->add($unitPrefix . '*');
+            $commands[] = [$unitPrefix . '*'];
         }
 
-        $process = $processBuilder->getProcess();
-
-        $process->run();
-        $output = $process->getOutput();
+        $output = $this->getCommandDispatcher()->dispatch(...$commands)->getOutput();
 
         return array_reduce($unitTypes, function ($carry, $unitSuffix) use ($output) {
             $result = Utils\OutputFetcher::fetchUnitNames($unitSuffix, $output);
+
             return array_merge($carry, $result);
         }, []);
     }
 
     /**
      * @param string $name
+     *
      * @return Service
      */
     public function getService(string $name): Service
     {
-        return new Service($name, $this->getProcessBuilder());
+        return new Service($name, $this->getCommandDispatcher());
     }
 
     /**
      * @param null|string $unitPrefix
+     *
      * @return Service[]
      */
     public function getServices(?string $unitPrefix = null): array
     {
         $units = $this->listUnits($unitPrefix, [Service::UNIT]);
 
         return array_map(function ($unitName) {
-            return new Service($unitName, $this->getProcessBuilder());
+            return new Service($unitName, $this->getCommandDispatcher());
         }, $units);
     }
 
     /**
      * @param string $name
+     *
      * @return Timer
      */
     public function getTimer(string $name): Timer
     {
-        return new Timer($name, $this->getProcessBuilder());
+        return new Timer($name, $this->getCommandDispatcher());
     }
 
     /**
      * @param null|string $unitPrefix
+     *
      * @return Timer[]
      */
     public function getTimers(?string $unitPrefix = null): array
     {
         $units = $this->listUnits($unitPrefix, [Timer::UNIT]);
 
         return array_map(function ($unitName) {
-            return new Timer($unitName, $this->getProcessBuilder());
+            return new Timer($unitName, $this->getCommandDispatcher());
         }, $units);
     }
 
     /**
-     * @return ProcessBuilder
+     * Restart the daemon to reload specs and new units
+     *
+     * @return bool
      */
-    public function getProcessBuilder(): ProcessBuilder
+    public function daemonReload(): bool
     {
-        $builder = ProcessBuilder::create();
-        $builder->setPrefix(self::$binary);
-        $builder->setTimeout(self::$timeout);
+        return $this->getCommandDispatcher()->dispatch('daemon-reload')->isSuccessful();
+    }
 
-        return $builder;
+    /**
+     * @return CommandDispatcherInterface
+     */
+    public function getCommandDispatcher(): CommandDispatcherInterface
+    {
+        if ($this->commandDispatcher === null) {
+            $this->commandDispatcher = (new SymfonyCommandDispatcher)
+                ->setTimeout(self::$timeout)
+                ->setBinary(self::$binary);
+        }
+
+        return $this->commandDispatcher;
     }
 
     /**
-     * Restart the daemon to reload specs and new units
+     * @param CommandDispatcherInterface $dispatcher
      *
-     * @return bool
+     * @return SystemCtl
      */
-    public function daemonReload(): bool
+    public function setCommandDispatcher(CommandDispatcherInterface $dispatcher)
     {
-        $processBuilder = $this->getProcessBuilder();
-        $processBuilder->add('daemon-reload');
-
-        $process = $processBuilder->getProcess();
-        $process->run();
+        $this->commandDispatcher = $dispatcher
+            ->setTimeout(self::$timeout)
+            ->setBinary(self::$binary);
 
-        return $process->isSuccessful();
+        return $this;
     }
 }