/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/AbstractBinary.php |
@@ -0,0 +1,220 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException; |
use Alchemy\BinaryDriver\Exception\ExecutionFailureException; |
use Alchemy\BinaryDriver\Listeners\Listeners; |
use Alchemy\BinaryDriver\Listeners\ListenerInterface; |
use Evenement\EventEmitter; |
use Monolog\Logger; |
use Monolog\Handler\NullHandler; |
use Psr\Log\LoggerInterface; |
use Symfony\Component\Process\ExecutableFinder; |
use Symfony\Component\Process\Process; |
|
abstract class AbstractBinary extends EventEmitter implements BinaryInterface |
{ |
/** @var ConfigurationInterface */ |
protected $configuration; |
|
/** @var ProcessBuilderFactoryInterface */ |
protected $factory; |
|
/** @var ProcessRunner */ |
private $processRunner; |
|
/** @var Listeners */ |
private $listenersManager; |
|
public function __construct(ProcessBuilderFactoryInterface $factory, LoggerInterface $logger, ConfigurationInterface $configuration) |
{ |
$this->factory = $factory; |
$this->configuration = $configuration; |
$this->processRunner = new ProcessRunner($logger, $this->getName()); |
$this->listenersManager = new Listeners(); |
$this->applyProcessConfiguration(); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function listen(ListenerInterface $listener) |
{ |
$this->listenersManager->register($listener, $this); |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function unlisten(ListenerInterface $listener) |
{ |
$this->listenersManager->unregister($listener, $this); |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function getConfiguration() |
{ |
return $this->configuration; |
} |
|
/** |
* {@inheritdoc} |
* |
* @return BinaryInterface |
*/ |
public function setConfiguration(ConfigurationInterface $configuration) |
{ |
$this->configuration = $configuration; |
$this->applyProcessConfiguration(); |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function getProcessBuilderFactory() |
{ |
return $this->factory; |
} |
|
/** |
* {@inheritdoc} |
* |
* @return BinaryInterface |
*/ |
public function setProcessBuilderFactory(ProcessBuilderFactoryInterface $factory) |
{ |
$this->factory = $factory; |
$this->applyProcessConfiguration(); |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function getProcessRunner() |
{ |
return $this->processRunner; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function setProcessRunner(ProcessRunnerInterface $runner) |
{ |
$this->processRunner = $runner; |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function command($command, $bypassErrors = false, $listeners = null) |
{ |
if (!is_array($command)) { |
$command = array($command); |
} |
|
return $this->run($this->factory->create($command), $bypassErrors, $listeners); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public static function load($binaries, LoggerInterface $logger = null, $configuration = array()) |
{ |
$finder = new ExecutableFinder(); |
$binary = null; |
$binaries = is_array($binaries) ? $binaries : array($binaries); |
|
foreach ($binaries as $candidate) { |
if (file_exists($candidate) && is_executable($candidate)) { |
$binary = $candidate; |
break; |
} |
if (null !== $binary = $finder->find($candidate)) { |
break; |
} |
} |
|
if (null === $binary) { |
throw new ExecutableNotFoundException(sprintf( |
'Executable not found, proposed : %s', implode(', ', $binaries) |
)); |
} |
|
if (null === $logger) { |
$logger = new Logger(__NAMESPACE__ . ' logger'); |
$logger->pushHandler(new NullHandler()); |
} |
|
$configuration = $configuration instanceof ConfigurationInterface ? $configuration : new Configuration($configuration); |
|
return new static(new ProcessBuilderFactory($binary), $logger, $configuration); |
} |
|
/** |
* Returns the name of the driver |
* |
* @return string |
*/ |
abstract public function getName(); |
|
/** |
* Executes a process, logs events |
* |
* @param Process $process |
* @param Boolean $bypassErrors Set to true to disable throwing ExecutionFailureExceptions |
* @param ListenerInterface|array $listeners A listener or an array of listener to register for this unique run |
* |
* @return string The Process output |
* |
* @throws ExecutionFailureException in case of process failure. |
*/ |
protected function run(Process $process, $bypassErrors = false, $listeners = null) |
{ |
if (null !== $listeners) { |
if (!is_array($listeners)) { |
$listeners = array($listeners); |
} |
|
$listenersManager = clone $this->listenersManager; |
|
foreach ($listeners as $listener) { |
$listenersManager->register($listener, $this); |
} |
} else { |
$listenersManager = $this->listenersManager; |
} |
|
return $this->processRunner->run($process, $listenersManager->storage, $bypassErrors); |
} |
|
private function applyProcessConfiguration() |
{ |
if ($this->configuration->has('timeout')) { |
$this->factory->setTimeout($this->configuration->get('timeout')); |
} |
|
return $this; |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/BinaryDriverTestCase.php |
@@ -0,0 +1,76 @@ |
<?php |
|
namespace Alchemy\BinaryDriver; |
|
use Psr\Log\LoggerInterface; |
use Symfony\Component\Process\Process; |
|
/** |
* Convenient PHPUnit methods for testing BinaryDriverInterface implementations. |
*/ |
class BinaryDriverTestCase extends \PHPUnit_Framework_TestCase |
{ |
/** |
* @return ProcessBuilderFactoryInterface |
*/ |
public function createProcessBuilderFactoryMock() |
{ |
return $this->getMock('Alchemy\BinaryDriver\ProcessBuilderFactoryInterface'); |
} |
|
/** |
* @param integer $runs The number of runs expected |
* @param Boolean $success True if the process expects to be successfull |
* @param string $commandLine The commandline executed |
* @param string $output The process output |
* @param string $error The process error output |
* |
* @return Process |
*/ |
public function createProcessMock($runs = 1, $success = true, $commandLine = null, $output = null, $error = null, $callback = false) |
{ |
$process = $this->getMockBuilder('Symfony\Component\Process\Process') |
->disableOriginalConstructor() |
->getMock(); |
|
$builder = $process->expects($this->exactly($runs)) |
->method('run'); |
|
if (true === $callback) { |
$builder->with($this->isInstanceOf('Closure')); |
} |
|
$process->expects($this->any()) |
->method('isSuccessful') |
->will($this->returnValue($success)); |
|
foreach (array( |
'getOutput' => $output, |
'getErrorOutput' => $error, |
'getCommandLine' => $commandLine, |
) as $command => $value) { |
$process |
->expects($this->any()) |
->method($command) |
->will($this->returnValue($value)); |
} |
|
return $process; |
} |
|
/** |
* @return LoggerInterface |
*/ |
public function createLoggerMock() |
{ |
return $this->getMock('Psr\Log\LoggerInterface'); |
} |
|
/** |
* @return ConfigurationInterface |
*/ |
public function createConfigurationMock() |
{ |
return $this->getMock('Alchemy\BinaryDriver\ConfigurationInterface'); |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/BinaryInterface.php |
@@ -0,0 +1,67 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
use Alchemy\BinaryDriver\Exception\ExecutableNotFoundException; |
use Alchemy\BinaryDriver\Exception\ExecutionFailureException; |
use Alchemy\BinaryDriver\Listeners\ListenerInterface; |
use Psr\Log\LoggerInterface; |
use Evenement\EventEmitterInterface; |
|
interface BinaryInterface extends ConfigurationAwareInterface, ProcessBuilderFactoryAwareInterface, ProcessRunnerAwareInterface, EventEmitterInterface |
{ |
/** |
* Adds a listener to the binary driver |
* |
* @param ListenerInterface $listener |
* |
* @return BinaryInterface |
*/ |
public function listen(ListenerInterface $listener); |
|
/** |
* Removes a listener from the binary driver |
* |
* @param ListenerInterface $listener |
* |
* @return BinaryInterface |
*/ |
public function unlisten(ListenerInterface $listener); |
|
/** |
* Runs a command against the driver. |
* |
* Calling this method on a `ls` driver with the command `-a` would run `ls -a`. |
* |
* @param array|string $command A command or an array of command |
* @param Boolean $bypassErrors If set to true, an erronous process will not throw an exception |
* @param ListenerInterface|array $listeners A listener or an array of listeners to register for this unique run |
* |
* @return string The command output |
* |
* @throws ExecutionFailureException in case of process failure. |
*/ |
public function command($command, $bypassErrors = false, $listeners = null); |
|
/** |
* Loads a binary |
* |
* @param string|array $binaries A binary name or an array of binary names |
* @param null|LoggerInterface $logger A Logger |
* @param array|ConfigurationInterface $configuration The configuration |
* |
* @throws ExecutableNotFoundException In case none of the binaries were found |
* |
* @return BinaryInterface |
*/ |
public static function load($binaries, LoggerInterface $logger = null, $configuration = array()); |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Configuration.php |
@@ -0,0 +1,107 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
class Configuration implements ConfigurationInterface |
{ |
private $data; |
|
public function __construct(array $data = array()) |
{ |
$this->data = $data; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function getIterator() |
{ |
return new \ArrayIterator($this->data); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function get($key, $default = null) |
{ |
return isset($this->data[$key]) ? $this->data[$key] : $default; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function set($key, $value) |
{ |
$this->data[$key] = $value; |
|
return $this; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function has($key) |
{ |
return array_key_exists($key, $this->data); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function remove($key) |
{ |
$value = $this->get($key); |
unset($this->data[$key]); |
|
return $value; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function all() |
{ |
return $this->data; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function offsetExists($offset) |
{ |
return $this->has($offset); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function offsetGet($offset) |
{ |
return $this->get($offset); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function offsetSet($offset, $value) |
{ |
$this->set($offset, $value); |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function offsetUnset($offset) |
{ |
$this->remove($offset); |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ConfigurationInterface.php |
@@ -0,0 +1,58 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
interface ConfigurationInterface extends \ArrayAccess, \IteratorAggregate |
{ |
/** |
* Returns the value given a key from configuration |
* |
* @param string $key |
* @param mixed $default The default value in case the key does not exist |
* |
* @return mixed |
*/ |
public function get($key, $default = null); |
|
/** |
* Set a value to configuration |
* |
* @param string $key The key |
* @param mixed $value The value corresponding to the key |
*/ |
public function set($key, $value); |
|
/** |
* Tells if Configuration contains `$key` |
* |
* @param string $key |
* |
* @return Boolean |
*/ |
public function has($key); |
|
/** |
* Removes a value given a key |
* |
* @param string $key |
* |
* @return mixed The previous value |
*/ |
public function remove($key); |
|
/** |
* Returns all values set in the configuration |
* |
* @return array |
*/ |
public function all(); |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Listeners/DebugListener.php |
@@ -0,0 +1,58 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver\Listeners; |
|
use Evenement\EventEmitter; |
use Symfony\Component\Process\Process; |
|
class DebugListener extends EventEmitter implements ListenerInterface |
{ |
private $prefixOut; |
private $prefixErr; |
private $eventOut; |
private $eventErr; |
|
public function __construct($prefixOut = '[OUT] ', $prefixErr = '[ERROR] ', $eventOut = 'debug', $eventErr = 'debug') |
{ |
$this->prefixOut = $prefixOut; |
$this->prefixErr = $prefixErr; |
$this->eventOut = $eventOut; |
$this->eventErr = $eventErr; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function handle($type, $data) |
{ |
if (Process::ERR === $type) { |
$this->emitLines($this->eventErr, $this->prefixErr, $data); |
} elseif (Process::OUT === $type) { |
$this->emitLines($this->eventOut, $this->prefixOut, $data); |
} |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function forwardedEvents() |
{ |
return array_unique(array($this->eventErr, $this->eventOut)); |
} |
|
private function emitLines($event, $prefix, $lines) |
{ |
foreach (explode("\n", $lines) as $line) { |
$this->emit($event, array($prefix . $line)); |
} |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/Listeners/Listeners.php |
@@ -0,0 +1,88 @@ |
<?php |
|
namespace Alchemy\BinaryDriver\Listeners; |
|
use SplObjectStorage; |
use Evenement\EventEmitter; |
|
class Listeners extends EventEmitter |
{ |
/** @var SplObjectStorage */ |
public $storage; |
|
public function __construct() |
{ |
$this->storage = new SplObjectStorage(); |
} |
|
public function __clone() |
{ |
$storage = $this->storage; |
$this->storage = new SplObjectStorage(); |
$this->storage->addAll($storage); |
} |
|
/** |
* Registers a listener, pass the listener events to the target. |
* |
* @param ListenerInterface $listener |
* @param null|EventEmitter $target |
* |
* @return ListenersInterface |
*/ |
public function register(ListenerInterface $listener, EventEmitter $target = null) |
{ |
$EElisteners = array(); |
|
if (null !== $target) { |
$EElisteners = $this->forwardEvents($listener, $target, $listener->forwardedEvents()); |
} |
|
$this->storage->attach($listener, $EElisteners); |
|
return $this; |
} |
|
/** |
* Unregisters a listener, removes the listener events from the target. |
* |
* @param ListenerInterface $listener |
* |
* @return ListenersInterface |
* |
* @throws InvalidArgumentException In case the listener is not registered |
*/ |
public function unregister(ListenerInterface $listener) |
{ |
if (!isset($this->storage[$listener])) { |
throw new InvalidArgumentException('Listener is not registered.'); |
} |
|
foreach ($this->storage[$listener] as $event => $EElistener) { |
$listener->removeListener($event, $EElistener); |
} |
|
$this->storage->detach($listener); |
|
return $this; |
} |
|
private function forwardEvents($source, $target, array $events) |
{ |
$EElisteners = array(); |
|
foreach ($events as $event) { |
$listener = $this->createListener($event, $target); |
$source->on($event, $EElisteners[$event] = $listener); |
} |
|
return $EElisteners; |
} |
|
private function createListener($event, $target) |
{ |
return function () use ($event, $target) { |
$target->emit($event, func_get_args()); |
}; |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessBuilderFactory.php |
@@ -0,0 +1,177 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
use Alchemy\BinaryDriver\Exception\InvalidArgumentException; |
use Symfony\Component\Process\ProcessBuilder; |
|
class ProcessBuilderFactory implements ProcessBuilderFactoryInterface |
{ |
/** |
* The binary path |
* |
* @var String |
*/ |
protected $binary; |
|
/** |
* The timeout for the generated processes |
* |
* @var integer|float |
*/ |
private $timeout; |
|
/** |
* An internal ProcessBuilder. |
* |
* Note that this one is used only if Symfony ProcessBuilder has method |
* setPrefix (2.3) |
* |
* @var ProcessBuilder |
*/ |
private $builder; |
|
/** |
* Tells whether Symfony LTS ProcessBuilder should be emulated or not. |
* |
* This symfony version provided a brand new ::setPrefix method. |
* |
* @var Boolean |
*/ |
public static $emulateSfLTS; |
|
/** |
* Constructor |
* |
* @param String $binary The path to the binary |
* |
* @throws InvalidArgumentException In case binary path is invalid |
*/ |
public function __construct($binary) |
{ |
$this->detectEmulation(); |
|
if (!self::$emulateSfLTS) { |
$this->builder = new ProcessBuilder(); |
} |
|
$this->useBinary($binary); |
} |
|
/** |
* Covenient method for unit testing |
* |
* @return type |
*/ |
public function getBuilder() |
{ |
return $this->builder; |
} |
|
/** |
* Covenient method for unit testing |
* |
* @param ProcessBuilder $builder |
* @return ProcessBuilderFactory |
*/ |
public function setBuilder(ProcessBuilder $builder) |
{ |
$this->builder = $builder; |
|
return $this; |
} |
|
/** |
* @inheritdoc |
*/ |
public function getBinary() |
{ |
return $this->binary; |
} |
|
/** |
* @inheritdoc |
*/ |
public function useBinary($binary) |
{ |
if (!is_executable($binary)) { |
throw new InvalidArgumentException(sprintf('`%s` is not an executable binary', $binary)); |
} |
|
$this->binary = $binary; |
|
if (!static::$emulateSfLTS) { |
$this->builder->setPrefix($binary); |
} |
|
return $this; |
} |
|
/** |
* @inheritdoc |
*/ |
public function setTimeout($timeout) |
{ |
$this->timeout = $timeout; |
|
if (!static::$emulateSfLTS) { |
$this->builder->setTimeout($this->timeout); |
} |
|
return $this; |
} |
|
/** |
* @inheritdoc |
*/ |
public function getTimeout() |
{ |
return $this->timeout; |
} |
|
/** |
* @inheritdoc |
*/ |
public function create($arguments = array()) |
{ |
if (null === $this->binary) { |
throw new InvalidArgumentException('No binary set'); |
} |
|
if (!is_array($arguments)) { |
$arguments = array($arguments); |
} |
|
if (static::$emulateSfLTS) { |
array_unshift($arguments, $this->binary); |
|
return ProcessBuilder::create($arguments) |
->setTimeout($this->timeout) |
->getProcess(); |
} else { |
return $this->builder |
->setArguments($arguments) |
->getProcess(); |
} |
} |
|
private function detectEmulation() |
{ |
if (null !== static::$emulateSfLTS) { |
return $this; |
} |
|
static::$emulateSfLTS = !method_exists('Symfony\Component\Process\ProcessBuilder', 'setPrefix'); |
|
return $this; |
} |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessBuilderFactoryInterface.php |
@@ -0,0 +1,65 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
use Alchemy\BinaryDriver\Exception\InvalidArgumentException; |
use Symfony\Component\Process\Process; |
|
interface ProcessBuilderFactoryInterface |
{ |
/** |
* Returns a new instance of Symfony Process |
* |
* @param string|array $arguments An argument or an array of arguments |
* |
* @return Process |
* |
* @throws InvalidArgumentException |
*/ |
public function create($arguments = array()); |
|
/** |
* Returns the path to the binary that is used |
* |
* @return String |
*/ |
public function getBinary(); |
|
/** |
* Sets the path to the binary |
* |
* @param String $binary A path to a binary |
* |
* @return ProcessBuilderFactoryInterface |
* |
* @throws InvalidArgumentException In case binary is not executable |
*/ |
public function useBinary($binary); |
|
/** |
* Set the default timeout to apply on created processes. |
* |
* @param integer|float $timeout |
* |
* @return ProcessBuilderFactoryInterface |
* |
* @throws InvalidArgumentException In case the timeout is not valid |
*/ |
public function setTimeout($timeout); |
|
/** |
* Returns the current timeout applied to the created processes. |
* |
* @return integer|float |
*/ |
public function getTimeout(); |
} |
/vendor/alchemy/binary-driver/src/Alchemy/BinaryDriver/ProcessRunner.php |
@@ -0,0 +1,104 @@ |
<?php |
|
/* |
* This file is part of Alchemy\BinaryDriver. |
* |
* (c) Alchemy <info@alchemy.fr> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Alchemy\BinaryDriver; |
|
use Alchemy\BinaryDriver\Exception\ExecutionFailureException; |
use Psr\Log\LoggerInterface; |
use SplObjectStorage; |
use Symfony\Component\Process\Exception\RuntimeException; |
use Symfony\Component\Process\Process; |
|
class ProcessRunner implements ProcessRunnerInterface |
{ |
/** @var LoggerInterface */ |
private $logger; |
|
/** @var string */ |
private $name; |
|
public function __construct(LoggerInterface $logger, $name) |
{ |
$this->logger = $logger; |
$this->name = $name; |
} |
|
/** |
* {@inheritdoc} |
* |
* @return ProcessRunner |
*/ |
public function setLogger(LoggerInterface $logger) |
{ |
$this->logger = $logger; |
|
return $this; |
} |
|
/** |
* @return LoggerInterface |
*/ |
public function getLogger() |
{ |
return $this->logger; |
} |
|
/** |
* {@inheritdoc} |
*/ |
public function run(Process $process, SplObjectStorage $listeners, $bypassErrors) |
{ |
$this->logger->info(sprintf( |
'%s running command %s', $this->name, $process->getCommandLine() |
)); |
|
try { |
$process->run($this->buildCallback($listeners)); |
} catch (RuntimeException $e) { |
if (!$bypassErrors) { |
$this->doExecutionFailure($process->getCommandLine(), $e); |
} |
} |
|
if (!$bypassErrors && !$process->isSuccessful()) { |
$this->doExecutionFailure($process->getCommandLine()); |
} elseif (!$process->isSuccessful()) { |
$this->logger->error(sprintf( |
'%s failed to execute command %s', $this->name, $process->getCommandLine() |
)); |
|
return; |
} else { |
$this->logger->info(sprintf('%s executed command successfully', $this->name)); |
|
return $process->getOutput(); |
} |
} |
|
private function buildCallback(SplObjectStorage $listeners) |
{ |
return function ($type, $data) use ($listeners) { |
foreach ($listeners as $listener) { |
$listener->handle($type, $data); |
} |
}; |
} |
|
private function doExecutionFailure($command, \Exception $e = null) |
{ |
$this->logger->error(sprintf( |
'%s failed to execute command %s', $this->name, $command |
)); |
throw new ExecutionFailureException(sprintf( |
'%s failed to execute command %s', $this->name, $command |
), $e ? $e->getCode() : null, $e ?: null); |
} |
} |