/**
* @param Error|Exception $ex
* @param mixed[] $params
* @return PromiseInterface
*/
public function handle($ex, $params = [])
{
foreach ($this->requires as $require) {
if (!isset($params[$require])) {
return Promise::doReject(new IllegalCallException('Missing parameter [' . $require . '] for [' . get_class($this) . '].'));
}
}
return Promise::doResolve([$ex, $params])->spread(function ($ex, $params) {
return $this->handler($ex, $params);
});
}
/**
* @param Error|Exception $ex
* @param mixed[] $params
* @return mixed
*/
protected function handler($ex, $params = [])
{
$manager = $this->runtime->manager();
$alias = $params['origin'];
if ($manager->existsThread($alias)) {
return $manager->createThread($alias, null, Runtime::CREATE_FORCE);
} else {
if ($manager->existsProcess($alias)) {
return $manager->createProcess($alias, null, Runtime::CREATE_FORCE);
}
}
return Promise::doReject(new RejectionException("Runtime [{$alias}] does not exists."));
}
/**
* @param int $flags
* @return PromiseInterface
*/
public function flushProcesses($flags = Runtime::DESTROY_KEEP)
{
return Promise::doReject(new RejectionException('Processes storage cannot be flushed.'));
}
/**
* @param Error|Exception $ex
* @param mixed[] $params
* @param int $try
* @return PromiseInterface
*/
public function handle($ex, $params = [], &$try = 0)
{
$classBaseEx = get_class($ex);
$classes = array_merge([$classBaseEx], class_parents($ex));
$indexMin = -1;
$chosen = null;
foreach ($classes as $class) {
$indexCurrent = array_search($class, array_keys($this->rules), true);
if ($indexCurrent !== false && ($indexMin === -1 || $indexCurrent < $indexMin)) {
$indexMin = $indexCurrent;
$chosen = $class;
}
}
if ($chosen === null) {
return Promise::doReject(new ExecutionException("SolverInterface [{$classBaseEx}] is not registered."));
}
$try++;
$params = array_merge($this->params, $params);
$valueOrPromise = $this->getHandler($chosen)->handle($ex, $params);
return Promise::doResolve($valueOrPromise);
}
/**
* @param string $command
* @param mixed[] $params
* @return PromiseInterface
*/
private function executeCommand($command, $params = [])
{
try {
return $this->commander->execute($command, $params);
} catch (Error $ex) {
return Promise::doReject($ex);
} catch (Exception $ex) {
return Promise::doReject($ex);
}
}
/**
* @param string $alias
* @return PromiseInterface
*/
public function stopRuntime($alias)
{
if ($this->existsThread($alias)) {
return $this->threadManager->stopThread($alias);
} else {
if ($this->existsProcess($alias)) {
return $this->processManager->stopProcess($alias);
}
}
return Promise::doReject(new ResourceUndefinedException("Runtime with alias [{$alias}] does not exist."));
}
/**
* @return PromiseInterface
*/
public function stop()
{
$state = $this->getState();
if ($state === Runtime::STATE_CREATED || $state === Runtime::STATE_DESTROYED) {
return Promise::doReject(new RejectionException("It is not possible to stop runtime from state [{$state}]."));
}
if ($state !== Runtime::STATE_STOPPED) {
$this->setState(Runtime::STATE_STOPPED);
$emitter = $this->eventEmitter();
$emitter->emit('beforeStop');
$emitter->emit('stop');
$emitter->emit('afterStop');
}
return Promise::doResolve('Runtime has been stopped.');
}
/**
* @param $aliases
* @return PromiseInterface
*/
public function stopThreads($aliases)
{
return Promise::doReject(new RejectionException("Threads could not be stopped."));
}
/**
* @param $aliases
* @return PromiseInterface
*/
public function stopProcesses($aliases)
{
return Promise::doReject(new RejectionException("Processes could not be stopped."));
}
/**
* @param string $alias
* @param int $flags
* @return PromiseInterface
*/
public function destroyProcess($alias, $flags = Runtime::DESTROY_FORCE_SOFT)
{
if (!isset($this->processes[$alias])) {
return Promise::doResolve("Process [{$alias}] was not needed to be destroyed, because it had not existed.");
}
$pid = $this->processes[$alias]['pid'];
$manager = $this;
if ($flags === Runtime::DESTROY_KEEP) {
return Promise::doReject(new ResourceDefinedException("Process [{$alias}] could not be destroyed with force level=DESTROY_KEEP."));
} else {
if ($flags === Runtime::DESTROY_FORCE_SOFT) {
$req = new Request($this->channel, $alias, new RuntimeCommand('container:destroy'));
return $req->call()->then(function ($value) use($manager, $alias) {
usleep(1000.0);
$manager->freeProcess($alias);
return $value;
});
} else {
if ($flags === Runtime::DESTROY_FORCE) {
$manager = $this;
return $manager->destroyProcess($alias, Runtime::DESTROY_FORCE_SOFT)->then(null, function () use($manager, $alias) {
return $manager->destroyProcess($alias, Runtime::DESTROY_FORCE_HARD);
});
}
}
}
if (!$this->system->existsPid($pid)) {
return Promise::doResolve()->then(function () use($manager, $alias) {
$manager->freeProcess($alias);
})->then(function () use($pid) {
return "Process with pid [{$pid}] was not needed to be destroyed, because it had not existed.";
});
} else {
if (!$this->system->kill($pid)) {
return Promise::doReject(new ResourceDefinedException("Process with pid [{$pid}] could not be killed forcefully."));
}
}
return Promise::doResolve()->then(function () use($manager, $alias) {
$manager->freeProcess($alias);
})->then(function () {
return "Process has been destroyed!";
});
}
