Executes the restarted command then deletes the tmp ini

@param string $command
165462
private function doRestart($command)
    {
        passthru($command, $exitCode);
        $this->notify(Status::INFO, 'Restarted process exited '.$exitCode);

        if ($this->debug === '2') {
            $this->notify(Status::INFO, 'Temp ini saved: '.$this->tmpIni);
        } else {
            @unlink($this->tmpIni);
        }

        exit($exitCode);
    }
651690
public function runCommand($command)
    {
        $this->setAutoExit(false);
        $argv = explode(' ','application '.$command);
        $input = new ArgvInput($argv);
        $this->run($input);
    }
1082630
protected function runCommand($command)
    {
        $process = new Process($command);

        $process->run();

        if ( ! $process->isSuccessful()) {
            throw new \RuntimeException($process->getErrorOutput());
        }

        return $process->getExitCode();
    }
869732
public function handle(RemoveIncidentCommand $command)
    {
        $incident = $command->incident;

        event(new IncidentWasRemovedEvent($this->auth->user(), $incident));

        $incident->delete();
    }
1231121
protected function _commandDeleteLocation($command)
    {
        $location = $this->getController()->getItem();
        $locatable = $command->locatable;

        $command->setAttribute('data-action', 'deleteLocation')
        ->setAttribute('data-location', $location->id)
        ->href($locatable->getURL());

        $command->label = translate('LIB-AN-ACTION-DELETE');
    }
716149
public function runCommand($command, OutputInterface $output = null)
    {
        $input = new StringInput($command);

        $command = $this->find($this->getCommandName($input));

        return $command->run($input, $output ?: new NullOutput());
    }
449686
protected function execute($command)
    {
        $process = proc_open($command, array(1 => array('pipe', 'w'), 2 => array('pipe', 'w')), $pipes);
        fclose($pipes[2]);
        $this->output = stream_get_contents($pipes[1]);
        fclose($pipes[1]);
        $status = proc_get_status($process);
        $this->status = $status['exitcode'];
        proc_close($process);
    }
1365839
protected function execute($command)
    {
        $process = new Process($command);
        $process->setTimeout(null);
        $process->run();

        if (!$process->isSuccessful()) {
            throw new \RuntimeException($process->getErrorOutput());
        }
    }
502941
public function remove($key = NULL)
    {
        $this->executeRemoveCommand();

        if( $key === NULL )
        {
            unlink($this->crontabCommands);
        }
        else
        {
            $this->removeJobFromExecFile($key);

            $this->executeCommand();
        }
    }
1298598
public function runSingleCommand($command)
    {
        $cmd = 'php ' . $this->directory . 'app/console ';

        return $this->phpci->executeCommand($cmd . $command, $this->directory);
    }
76243
protected function execute($command)
    {
        $process = new Process($command, null, null, null, $this->timeout);
        $process->run();

        if (!$process->isSuccessful()) {
            throw new \RuntimeException($process->getErrorOutput());
        }
    }
497658
protected function run($command)
    {
        if (array_key_exists('migrationPath', $this->config)) {
            $migrationPaths = $this->config['migrationPath'];

            if (is_string($migrationPaths)) {
                $migrationPaths = [$migrationPaths];
            }

            $this->runMigrationByPaths($migrationPaths, $command);
        } elseif (array_key_exists('migrationNamespaces', $this->config)) {
            $migrationNamespaces = $this->config['migrationNamespaces'];

            if (is_string($migrationNamespaces)) {
                $migrationNamespaces = [$migrationNamespaces];
            }

            $this->runMigrationByNamespaces($migrationNamespaces, $command);
        } else {
            $this->runMigrationByApplication($command);
        }
    }
755481
protected function executeCommand($command, $timeout = 300, $callback = null)
    {
        $process = new Process($this->prepare($command), $this->cwd, null, null, $timeout);
        $process->run($callback);
        if (!$process->isSuccessful()) {
            throw new \RuntimeException(sprintf('An error occurred when executing the "%s" command.', $command));
        }
    }
1039280
public function handle(RemoveMetricCommand $command)
    {
        $metric = $command->metric;

        event(new MetricWasRemovedEvent($this->auth->user(), $metric));

        $metric->delete();
    }
1272132
public function update($command = null)
    {
        $this->command = $this->instantiateCommand($command);

        $this->helper->downloadFiles();

        $this->countries->update();

        $this->currencies->update();

        $this->loadCountries();

        $this->states->update();

        $this->cities->update();

        $this->taxes->update();

        $this->timezones->update();

        $this->helper->deleteTemporaryFiles();
    }
1080286
protected function runGrumPhpCommand(string $command)
    {
        $config = $this->composer->getConfig();
        $commandLocator = new ExternalCommand($config->get('bin-dir'), new ExecutableFinder());
        $executable = $commandLocator->locate('grumphp');

        $commandlineArgs = ProcessArgumentsCollection::forExecutable($executable);
        $commandlineArgs->add($command);
        $commandlineArgs->add('--no-interaction');

        $process = ProcessFactory::fromArguments($commandlineArgs);

        // Check executable which is running:
        if ($this->io->isVeryVerbose()) {
            $this->io->write('Running process : '.$process->getCommandLine());
        }

        $process->run();
        if (!$process->isSuccessful()) {
            $this->io->write(
                '<fg=red>GrumPHP can not sniff your commits. Did you specify the correct git-dir?</fg=red>'
            );
            $this->io->write('<fg=red>'.$process->getErrorOutput().'</fg=red>');

            return;
        }

        $this->io->write('<fg=yellow>'.$process->getOutput().'</fg=yellow>');
    }
1349103
public function execute($command)
    {
        exec($command, $result, $returnValue);

        if ($returnValue === 0) {
            return $result;
        }

        throw new \RuntimeException(sprintf('Failed to execute command: %s', $command), $returnValue);
    }