Add user/system scope to systemctl command dispatching

Author: icanhazstring

src/Command/CommandDispatcherInterface.php

@@ -31,6 +31,15 @@ public function setTimeout(int $timeout): CommandDispatcherInterface;
      */
     public function setBinary(string $binary): CommandDispatcherInterface;
 
+    /**
+     * Set additional arguments to be passed to dispatch
+     *
+     * @param string[] $arguments
+     *
+     * @return CommandDispatcherInterface
+     */
+    public function setArguments(array $arguments): CommandDispatcherInterface;
+
     /**
      * Dispatch given commands against implementers logic and creating a new command
      * to read results

src/Command/SymfonyCommandDispatcher.php

@@ -13,8 +13,12 @@
  */
 class SymfonyCommandDispatcher implements CommandDispatcherInterface
 {
+    /** @var string */
     private $binary;
-    private $timetout;
+    /** @var float */
+    private $timeout;
+    /** @var string[] */
+    private $arguments = [];
 
     /**
      * @inheritdoc
@@ -31,20 +35,54 @@ public function setBinary(string $binary): CommandDispatcherInterface
      */
     public function setTimeout(int $timeout): CommandDispatcherInterface
     {
-        $this->timetout = $timeout;
+        $this->timeout = $timeout;
 
         return $this;
     }
 
+    /**
+     * @inheritdoc
+     */
+    public function setArguments(array $arguments): CommandDispatcherInterface
+    {
+        $this->arguments = $arguments;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getBinary(): string
+    {
+        return $this->binary;
+    }
+
+    /**
+     * @return float
+     */
+    public function getTimeout(): float
+    {
+        return $this->timeout;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getArguments(): array
+    {
+        return $this->arguments;
+    }
+
     /**
      * @inheritDoc
      */
     public function dispatch(string ...$commands): CommandInterface
     {
         $processBuilder = new ProcessBuilder();
         $processBuilder->setPrefix($this->binary);
-        $processBuilder->setTimeout($this->timetout);
-        $processBuilder->setArguments($commands);
+        $processBuilder->setTimeout($this->timeout);
+        $processBuilder->setArguments(array_merge($this->arguments, $commands));
 
         $process = new SymfonyCommand($processBuilder->getProcess());
 

src/Scope/ScopeInterface.php

@@ -0,0 +1,20 @@
+<?php
+declare(strict_types=1);
+
+namespace SystemCtl\Scope;
+
+/**
+ * ScopeInterface
+ *
+ * @package SystemCtl\Scope
+ * @author  icanhazstring <[email protected]>
+ */
+interface ScopeInterface
+{
+    /**
+     * Return scope argument value for dispatching commands
+     *
+     * @return string
+     */
+    public function __toString(): string;
+}

src/Scope/SystemScope.php

@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace SystemCtl\Scope;
+
+/**
+ * SystemScope
+ *
+ * @package SystemCtl\Scope
+ * @author  icanhazstring <[email protected]>
+ */
+class SystemScope implements ScopeInterface
+{
+    /**
+     * @inheritdoc
+     */
+    public function __toString(): string
+    {
+        return '--system';
+    }
+}

src/Scope/UserScope.php

@@ -0,0 +1,21 @@
+<?php
+declare(strict_types=1);
+
+namespace SystemCtl\Scope;
+
+/**
+ * UserScope
+ *
+ * @package SystemCtl\Scope
+ * @author  icanhazstring <[email protected]>
+ */
+class UserScope implements ScopeInterface
+{
+    /**
+     * @inheritdoc
+     */
+    public function __toString(): string
+    {
+        return '--user';
+    }
+}

src/SystemCtl.php

@@ -7,6 +7,9 @@
 use SystemCtl\Command\SymfonyCommandDispatcher;
 use SystemCtl\Exception\UnitNotFoundException;
 use SystemCtl\Exception\UnitTypeNotSupportedException;
+use SystemCtl\Scope\ScopeInterface;
+use SystemCtl\Scope\SystemScope;
+use SystemCtl\Scope\UserScope;
 use SystemCtl\Template\AbstractUnitTemplate;
 use SystemCtl\Template\Installer\UnitInstaller;
 use SystemCtl\Template\Installer\UnitInstallerInterface;
@@ -41,6 +44,9 @@ class SystemCtl
     /** @var UnitInstallerInterface */
     private $unitInstaller;
 
+    /** @var ScopeInterface */
+    private $scope;
+
     public const AVAILABLE_UNITS = [
         Service::UNIT,
         'socket',
@@ -132,6 +138,42 @@ public function listUnits(?string $unitPrefix = null, array $unitTypes = self::S
         }, []);
     }
 
+    /**
+     * Current scope this system ctl instance is running
+     *
+     * @return ScopeInterface
+     */
+    public function getScope(): ScopeInterface
+    {
+        if ($this->scope === null) {
+            $this->scope = new SystemScope;
+        }
+
+        return $this->scope;
+    }
+
+    /**
+     * Switch to user scope
+     *
+     * @return SystemCtl
+     */
+    public function user(): self
+    {
+        $this->scope = new UserScope;
+
+        return $this;
+    }
+
+    /**
+     * Switch to system scope
+     */
+    public function system(): self
+    {
+        $this->scope = new SystemScope;
+
+        return $this;
+    }
+
     /**
      * @param string $name
      *
@@ -213,6 +255,8 @@ public function getCommandDispatcher(): CommandDispatcherInterface
                 ->setBinary(self::$binary);
         }
 
+        $this->commandDispatcher->setArguments([(string)$this->getScope()]);
+
         return $this->commandDispatcher;
     }
 

src/Template/Installer/UnitInstaller.php

@@ -27,6 +27,7 @@ class UnitInstaller implements UnitInstallerInterface
     public function setPath(string $path): UnitInstallerInterface
     {
         $this->path = rtrim($path, '/');
+
         return $this;
     }
 

tests/Functional/Command/SymfonyCommandDispatcherTest.php

@@ -23,6 +23,6 @@ public function itShouldDispatchACorrectCommand()
         $dispatcher->setBinary('echo');
 
         $output = $dispatcher->dispatch('a')->getOutput();
-        $this->assertEquals('a', trim($output));
+        self::assertEquals('a', trim($output));
     }
 }

tests/Integration/SystemCtlTest.php

@@ -61,6 +61,7 @@ private function buildCommandDispatcherStub(): ObjectProphecy
         $commandDispatcherStub = $this->prophesize(CommandDispatcherInterface::class);
         $commandDispatcherStub->setTimeout(Argument::type('int'))->willReturn($commandDispatcherStub);
         $commandDispatcherStub->setBinary(Argument::type('string'))->willReturn($commandDispatcherStub);
+        $commandDispatcherStub->setArguments(Argument::type('array'))->willReturn($commandDispatcherStub);
 
         return $commandDispatcherStub;
     }
@@ -105,7 +106,7 @@ public function testListUnitsWithAvailableUnits()
         $systemctl->setCommandDispatcher($dispatcherStub->reveal());
 
         $units = $systemctl->listUnits(null, SystemCtl::AVAILABLE_UNITS);
-        $this->assertCount(11, $units);
+        self::assertCount(11, $units);
     }
 
     public function testListUnitsWithSupportedUnits()
@@ -134,7 +135,7 @@ public function testListUnitsWithSupportedUnits()
         $systemctl->setCommandDispatcher($dispatcherStub->reveal());
 
         $units = $systemctl->listUnits();
-        $this->assertCount(5, $units);
+        self::assertCount(5, $units);
     }
 
     public function testGetServices()
@@ -159,7 +160,7 @@ public function testGetServices()
 
         $services = $systemctl->getServices();
 
-        $this->assertCount(2, $services);
+        self::assertCount(2, $services);
     }
 
     public function testGetTimers()
@@ -183,7 +184,7 @@ public function testGetTimers()
         $systemctl->setCommandDispatcher($dispatcherStub->reveal());
         $timers = $systemctl->getTimers();
 
-        $this->assertCount(2, $timers);
+        self::assertCount(2, $timers);
     }
 
     /**
@@ -195,12 +196,12 @@ public function itShouldReturnTrueOnSuccessfulDaemonReload()
         $command->isSuccessful()->willReturn(true);
 
         $dispatcher = $this->buildCommandDispatcherStub();
-        $dispatcher->dispatch(Argument::exact('daemon-reload'))->willReturn($command);
+        $dispatcher->dispatch('daemon-reload')->willReturn($command);
 
         $systemCtl = new SystemCtl();
         $systemCtl->setCommandDispatcher($dispatcher->reveal());
 
-        $this->assertTrue($systemCtl->daemonReload());
+        self::assertTrue($systemCtl->daemonReload());
     }
 
     /**
@@ -239,7 +240,7 @@ public function itShouldReturnUnitAfterInstall()
 
         $unit = $systemctl->install($unitTemplate);
 
-        $this->assertEquals($unitName, $unit->getName());
+        self::assertEquals($unitName, $unit->getName());
     }
 
     /**
@@ -250,6 +251,28 @@ public function itShouldReturnDefaultInstallerIfReceived()
         SystemCtl::setAssetPath('vfs://');
 
         $systemCtl = new SystemCtl;
-        $this->assertInstanceOf(UnitInstaller::class, $systemCtl->getUnitInstaller());
+        self::assertInstanceOf(UnitInstaller::class, $systemCtl->getUnitInstaller());
+    }
+
+    /**
+     * @test
+     */
+    public function itShouldAddScopeArgumentToDispatcher()
+    {
+        $output = 'testService.service Active';
+
+        $dispatcher = $this->buildCommandDispatcherStub();
+        $dispatcher->setArguments(['--system'])->shouldBeCalled()->willReturn($dispatcher->reveal());
+        $dispatcher->dispatch('list-units', 'testService')
+            ->shouldBeCalled()
+            ->willReturn($this->buildCommandStub($output));
+
+        $systemCtl = new SystemCtl;
+        $systemCtl->setCommandDispatcher($dispatcher->reveal());
+
+        $systemCtl->getService('testService');
+
+        $dispatcher->setArguments(['--user'])->shouldBeCalled()->willReturn($dispatcher->reveal());
+        $systemCtl->user()->getService('testService');
     }
 }

tests/Integration/Template/Installer/UnitInstallerTest.php

@@ -77,7 +77,7 @@ public function itShouldCreateTargetFile()
 
         $installer = (new UnitInstaller)->setPath('vfs://units/')->setRenderer($renderer);
 
-        $this->assertTrue($installer->install($template));
+        self::assertTrue($installer->install($template));
 
         /** @var File $file */
         $file = self::$fileSystem->get('/units/awesomeService.service');
@@ -89,6 +89,6 @@ public function itShouldCreateTargetFile()
 EOF;
 
 
-        $this->assertEquals($expected, $file->getContent());
+        self::assertEquals($expected, $file->getContent());
     }
 }