Rework receiving and execution of units.

This is preparation for v1.0 to implement all kind of units and creation of units.

Author: icanhazstring

composer.lock

@@ -2,27 +2,27 @@
 
 namespace SystemCtl\Exception;
 
+/**
+ * CommandFailedException
+ *
+ * @method static CommandFailedException fromService(string $unitName, string $command)
+ * @method static CommandFailedException fromTimer(string $unitName, string $command)
+ *
+ * @package SystemCtl\Exception
+ *
+ * @author icanhazstring <[email protected]>
+ */
 class CommandFailedException extends \Exception
 {
-    /**
-     * @param $name
-     * @param $command
-     *
-     * @return CommandFailedException
-     */
-    public static function fromService($name, $command): CommandFailedException
+    public static function __callStatic($name, $arguments)
     {
-        return new self(sprintf('Failed to %s service %s', $command, $name));
-    }
+        preg_match('/from(?<unit>.*)/', $name, $match);
 
-    /**
-     * @param $name
-     * @param $command
-     *
-     * @return CommandFailedException
-     */
-    public static function fromTimer($name, $command): CommandFailedException
-    {
-        return new self(sprintf('Failed to %s timer %s', $command, $name));
+        $unit = strtolower($match['unit']);
+
+        $unitName = $arguments[0];
+        $command = $arguments[1];
+
+        return new self("Failed to {$command} {$unit} {$unitName}");
     }
 }

src/Exception/CommandFailedException.php

@@ -1,6 +1,5 @@
 <?php
 
-
 namespace SystemCtl\Exception;
 
 class UnitTypeNotSupportedException extends \Exception

src/Exception/UnitTypeNotSupportedException.php

@@ -4,10 +4,23 @@
 
 use Symfony\Component\Process\ProcessBuilder;
 use SystemCtl\Exception\UnitTypeNotSupportedException;
+use SystemCtl\Unit\AbstractUnit;
 use SystemCtl\Unit\Service;
 use SystemCtl\Unit\Timer;
 use SystemCtl\Unit\UnitInterface;
 
+/**
+ * SystemCtl
+ *
+ * @method Service getService(string $unit)
+ * @method Timer getTimer(string $unit)
+ *
+ * @method array getServices(?string $unitPrefix = null)
+ * @method array getTimers(?string $unitPrefix = null)
+ *
+ * @package SystemCtl
+ * @author icanhazstring <[email protected]>
+ */
 class SystemCtl
 {
     /** @var string systemctl binary path */
@@ -100,47 +113,52 @@ public function listUnits(?string $unitPrefix = null, array $unitTypes = self::S
         }, []);
     }
 
-    /**
-     * @param string $name
-     * @return Service
-     */
-    public function getService(string $name): Service
+    public function __call($name, $arguments)
     {
-        return new Service($name, $this->getProcessBuilder());
-    }
+        preg_match('/get(?<unit>[^s]+)(?<plural>s)?/', $name, $match);
 
-    /**
-     * @param null|string $unitPrefix
-     * @return Service[]
-     */
-    public function getServices(?string $unitPrefix = null): array
-    {
-        $units = $this->listUnits($unitPrefix, [Service::UNIT]);
+        $isPlural = isset($match['plural']);
+        $unitName = strtolower($match['unit']);
 
-        return array_map(function ($unitName) {
-            return new Service($unitName, $this->getProcessBuilder());
-        }, $units);
+        if (!in_array($unitName, self::SUPPORTED_UNITS)) {
+            throw new UnitTypeNotSupportedException("Unit {$unitName} not supported");
+        }
+
+        // Singular differs requested name?
+        // Get a list of units
+        if ($isPlural) {
+            return $this->getUnits(ucfirst($unitName), $arguments);
+        }
+
+        return $this->getUnit(ucfirst($unitName), $arguments);
     }
 
     /**
-     * @param string $name
-     * @return Timer
+     * @param string $unitClass
+     * @param $args
+     * @return AbstractUnit
      */
-    public function getTimer(string $name): Timer
+    private function getUnit(string $unitClass, $args): AbstractUnit
     {
-        return new Timer($name, $this->getProcessBuilder());
+        $args[] = $this->getProcessBuilder();
+        $className = '\SystemCtl\Unit\\' . $unitClass;
+
+        return new $className(...$args);
     }
 
     /**
-     * @param null|string $unitPrefix
-     * @return Timer[]
+     * @param string $unitName
+     * @param $arguments
+     * @return array
      */
-    public function getTimers(?string $unitPrefix = null): array
+    private function getUnits(string $unitName, $arguments): array
     {
-        $units = $this->listUnits($unitPrefix, [Timer::UNIT]);
+        $unitPrefix = $arguments[0] ?? null;
+        $units = $this->listUnits($unitPrefix, [strtolower($unitName)]);
+        $unitClass = '\SystemCtl\Unit\\' . $unitName;
 
-        return array_map(function ($unitName) {
-            return new Timer($unitName, $this->getProcessBuilder());
+        return array_map(function ($unitName) use ($unitClass) {
+            return new $unitClass($unitName, $this->getProcessBuilder());
         }, $units);
     }
 

src/SystemCtl.php

@@ -3,9 +3,13 @@
 namespace SystemCtl\Unit;
 
 use Symfony\Component\Process\ProcessBuilder;
+use SystemCtl\Exception\CommandFailedException;
 
 abstract class AbstractUnit implements UnitInterface
 {
+    /** @var string */
+    protected $type;
+
     /** @var string */
     private $name;
 
@@ -53,36 +57,55 @@ public function getInstanceName(): ?string
      * Execute a single command
      *
      * @param string $command
+     * @param bool $raise
+     *
+     * @throws CommandFailedException Raised if process was not successful and user wants to raise exception
+     *                                instead of returning the actual process exit code
+     *
      * @return bool
      */
-    abstract protected function execute(string $command): bool;
+    protected function execute(string $command, bool $raise = true): bool
+    {
+        $process = $this->processBuilder
+            ->setArguments([$command, $this->getName()])
+            ->getProcess();
 
-    public function start(): bool
+        $process->run();
+
+        if (!$process->isSuccessful() && $raise) {
+            $exceptionCall = CommandFailedException::class . '::from' . ucfirst($this->type);
+            throw call_user_func_array($exceptionCall, [$this->getName(), $command]);
+        }
+
+        return $process->isSuccessful();
+    }
+
+    public function start(bool $raise = true): bool
     {
-        return $this->execute(__FUNCTION__);
+        return $this->execute(__FUNCTION__, $raise);
     }
 
-    public function stop(): bool
+    public function stop(bool $raise = true): bool
     {
         return $this->execute(__FUNCTION__);
     }
 
-    public function disable(): bool
+    public function disable(bool $raise = true): bool
     {
         return $this->execute(__FUNCTION__);
     }
 
-    public function reload(): bool
+    public function reload(bool $raise = true): bool
     {
         return $this->execute(__FUNCTION__);
     }
 
-    public function restart(): bool
+    public function restart(bool $raise = true): bool
     {
         return $this->execute(__FUNCTION__);
     }
 
-    public function enable(): bool
+    public function enable(bool $raise = true): bool
     {
         return $this->execute(__FUNCTION__);
     }

src/Unit/AbstractUnit.php

@@ -3,24 +3,15 @@
 
 namespace SystemCtl\Unit;
 
-use SystemCtl\Exception\CommandFailedException;
+use Symfony\Component\Process\ProcessBuilder;
 
 class Service extends AbstractUnit
 {
     public const UNIT = 'service';
 
-    protected function execute(string $command): bool
+    public function __construct($name, ProcessBuilder $processBuilder)
     {
-        $process = $this->processBuilder
-            ->setArguments([$command, $this->getName()])
-            ->getProcess();
-
-        $process->run();
-
-        if (!$process->isSuccessful()) {
-            throw CommandFailedException::fromService($this->getName(), $command);
-        }
-
-        return true;
+        parent::__construct($name, $processBuilder);
+        $this->type = self::UNIT;
     }
 }

src/Unit/Service.php

@@ -2,24 +2,18 @@
 
 namespace SystemCtl\Unit;
 
-use SystemCtl\Exception\CommandFailedException;
+use Symfony\Component\Process\ProcessBuilder;
 
 class Timer extends AbstractUnit
 {
     public const UNIT = 'timer';
 
-    protected function execute(string $command): bool
+    /**
+     * @inheritdoc
+     */
+    public function __construct($name, ProcessBuilder $processBuilder)
     {
-        $process = $this->processBuilder
-            ->setArguments([$command, $this->getName()])
-            ->getProcess();
-
-        $process->run();
-
-        if (!$process->isSuccessful()) {
-            throw CommandFailedException::fromTimer($this->getName(), $command);
-        }
-
-        return true;
+        parent::__construct($name, $processBuilder);
+        $this->type = self::UNIT;
     }
 }

src/Unit/Timer.php

@@ -5,7 +5,7 @@
 /**
  * UnitInterface for handling single units
  *
- * @package SystemCtl
+ * @package SystemCtl\Unit
  */
 interface UnitInterface
 {

src/Unit/UnitInterface.php

@@ -97,6 +97,14 @@ public function testCreateUnitFromUnsupportedSuffixShouldRaiseException()
         SystemCtl::unitFromSuffix('unsupported', 'FailUnit');
     }
 
+    public function testGetUnitFromUnsupportedShouldRaiseException()
+    {
+        $systemctl = $this->buildSystemCtlMock('');
+
+        $this->expectException(UnitTypeNotSupportedException::class);
+        $systemctl->getFubar('Test');
+    }
+
     public function testGetServiceWithName()
     {
         $output = 'testService.service Active Running';