Commit eec0a032 authored by Tobias Hunger's avatar Tobias Hunger
Browse files

Vcs: Split up VcsCommand



Move the biggest chunk into Utils::ShellCommand, add some Qt Creator
specific magic in Core::ShellCommand and leave the rest in
VcsBase::VcsCommand.

Change-Id: I5fe6f7076e96023ad2164bcfaacfb3b65a7ff8a8
Reviewed-by: Orgad Shaneh's avatarOrgad Shaneh <orgads@gmail.com>
parent 1e1fee86
/**************************************************************************
**
** Copyright (C) 2015 Brian McGillion and Hugues Delorme
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "shellcommand.h"
#include "fileutils.h"
#include "synchronousprocess.h"
#include "runextensions.h"
#include "qtcassert.h"
#include <QProcess>
#include <QProcessEnvironment>
#include <QFuture>
#include <QFutureWatcher>
#include <QtConcurrentRun>
#include <QFileInfo>
#include <QCoreApplication>
#include <QVariant>
#include <QScopedPointer>
#include <QSharedPointer>
#include <QStringList>
#include <QTextCodec>
#include <QMutex>
/*!
\fn void Utils::ProgressParser::parseProgress(const QString &text)
Reimplement to parse progress as it appears in the standard output.
If a progress string is detected, call \c setProgressAndMaximum() to update
the progress bar accordingly.
\sa Utils::ProgressParser::setProgressAndMaximum()
*/
/*!
\fn void Utils::ProgressParser::setProgressAndMaximum(int value, int maximum)
Sets progress \a value and \a maximum for current command. Called by \c parseProgress()
when a progress string is detected.
*/
namespace Utils {
namespace Internal {
class ShellCommandPrivate
{
public:
struct Job {
explicit Job(const Utils::FileName &b, const QStringList &a, int t,
Utils::ExitCodeInterpreter *interpreter = 0);
Utils::FileName binary;
QStringList arguments;
int timeoutS;
Utils::ExitCodeInterpreter *exitCodeInterpreter;
};
ShellCommandPrivate(const QString &workingDirectory, const QProcessEnvironment &environment);
~ShellCommandPrivate();
std::function<OutputProxy *()> m_proxyFactory = []() { return new OutputProxy; };
QString m_displayName;
const QString m_workingDirectory;
const QProcessEnvironment m_environment;
QVariant m_cookie;
int m_defaultTimeoutS;
unsigned m_flags;
QTextCodec *m_codec;
ProgressParser *m_progressParser;
bool m_progressiveOutput;
bool m_hadOutput;
bool m_aborted;
QFutureWatcher<void> m_watcher;
QList<Job> m_jobs;
bool m_lastExecSuccess;
int m_lastExecExitCode;
};
ShellCommandPrivate::ShellCommandPrivate(const QString &workingDirectory,
const QProcessEnvironment &environment) :
m_workingDirectory(workingDirectory),
m_environment(environment),
m_defaultTimeoutS(10),
m_flags(0),
m_codec(0),
m_progressParser(0),
m_progressiveOutput(false),
m_hadOutput(false),
m_aborted(false),
m_lastExecSuccess(false),
m_lastExecExitCode(-1)
{ }
ShellCommandPrivate::~ShellCommandPrivate()
{
delete m_progressParser;
}
ShellCommandPrivate::Job::Job(const Utils::FileName &b, const QStringList &a,
int t, Utils::ExitCodeInterpreter *interpreter) :
binary(b),
arguments(a),
timeoutS(t),
exitCodeInterpreter(interpreter)
{
// Finished cookie is emitted via queued slot, needs metatype
static const int qvMetaId = qRegisterMetaType<QVariant>();
Q_UNUSED(qvMetaId)
}
} // namespace Internal
ShellCommand::ShellCommand(const QString &workingDirectory,
const QProcessEnvironment &environment) :
d(new Internal::ShellCommandPrivate(workingDirectory, environment))
{ }
ShellCommand::~ShellCommand()
{
delete d;
}
QString ShellCommand::displayName() const
{
if (!d->m_displayName.isEmpty())
return d->m_displayName;
if (!d->m_jobs.isEmpty()) {
const Internal::ShellCommandPrivate::Job &job = d->m_jobs.at(0);
QString result = job.binary.toFileInfo().baseName();
result[0] = result.at(0).toTitleCase();
if (!job.arguments.isEmpty())
result += QLatin1Char(' ') + job.arguments.at(0);
return result;
}
return tr("Unknown");
}
void ShellCommand::setDisplayName(const QString &name)
{
d->m_displayName = name;
}
const QString &ShellCommand::workingDirectory() const
{
return d->m_workingDirectory;
}
const QProcessEnvironment ShellCommand::processEnvironment() const
{
return d->m_environment;
}
int ShellCommand::defaultTimeoutS() const
{
return d->m_defaultTimeoutS;
}
void ShellCommand::setDefaultTimeoutS(int timeout)
{
d->m_defaultTimeoutS = timeout;
}
unsigned ShellCommand::flags() const
{
return d->m_flags;
}
void ShellCommand::addFlags(unsigned f)
{
d->m_flags |= f;
}
void ShellCommand::addJob(const Utils::FileName &binary, const QStringList &arguments,
Utils::ExitCodeInterpreter *interpreter)
{
addJob(binary, arguments, defaultTimeoutS(), interpreter);
}
void ShellCommand::addJob(const Utils::FileName &binary, const QStringList &arguments, int timeoutS,
Utils::ExitCodeInterpreter *interpreter)
{
d->m_jobs.push_back(Internal::ShellCommandPrivate::Job(binary, arguments, timeoutS, interpreter));
}
void ShellCommand::execute()
{
d->m_lastExecSuccess = false;
d->m_lastExecExitCode = -1;
if (d->m_jobs.empty())
return;
// For some reason QtConcurrent::run() only works on this
QFuture<void> task = QtConcurrent::run(&ShellCommand::run, this);
d->m_watcher.setFuture(task);
connect(&d->m_watcher, &QFutureWatcher<void>::canceled, this, &ShellCommand::cancel);
addTask(task);
}
void ShellCommand::abort()
{
d->m_aborted = true;
d->m_watcher.future().cancel();
}
void ShellCommand::cancel()
{
emit terminate();
}
unsigned ShellCommand::processFlags() const
{
return 0;
}
void ShellCommand::addTask(QFuture<void> &future)
{
Q_UNUSED(future);
}
bool ShellCommand::lastExecutionSuccess() const
{
return d->m_lastExecSuccess;
}
int ShellCommand::lastExecutionExitCode() const
{
return d->m_lastExecExitCode;
}
void ShellCommand::run(QFutureInterface<void> &future)
{
// Check that the binary path is not empty
QTC_ASSERT(!d->m_jobs.isEmpty(), return);
QString stdOut;
QString stdErr;
if (d->m_progressParser)
d->m_progressParser->setFuture(&future);
else
future.setProgressRange(0, 1);
const int count = d->m_jobs.size();
d->m_lastExecExitCode = -1;
d->m_lastExecSuccess = true;
for (int j = 0; j < count; j++) {
const Internal::ShellCommandPrivate::Job &job = d->m_jobs.at(j);
Utils::SynchronousProcessResponse resp
= runCommand(job.binary, job.arguments, job.timeoutS, job.exitCodeInterpreter);
stdOut += resp.stdOut;
stdErr += resp.stdErr;
d->m_lastExecExitCode = resp.exitCode;
d->m_lastExecSuccess = resp.result == Utils::SynchronousProcessResponse::Finished;
if (!d->m_lastExecSuccess)
break;
}
if (!d->m_aborted) {
if (!d->m_progressiveOutput) {
emit output(stdOut);
if (!stdErr.isEmpty())
emit errorText(stdErr);
}
emit finished(d->m_lastExecSuccess, d->m_lastExecExitCode, cookie());
if (d->m_lastExecSuccess)
emit success(cookie());
future.setProgressValue(future.progressMaximum());
}
if (d->m_progressParser)
d->m_progressParser->setFuture(0);
// As it is used asynchronously, we need to delete ourselves
this->deleteLater();
}
Utils::SynchronousProcessResponse ShellCommand::runCommand(const Utils::FileName &binary,
const QStringList &arguments, int timeoutS,
Utils::ExitCodeInterpreter *interpreter)
{
Utils::SynchronousProcessResponse response;
if (binary.isEmpty()) {
response.result = Utils::SynchronousProcessResponse::StartFailed;
return response;
}
QSharedPointer<OutputProxy> proxy(d->m_proxyFactory());
if (!(d->m_flags & SuppressCommandLogging))
proxy->appendCommand(d->m_workingDirectory, binary, arguments);
if (d->m_flags & FullySynchronously) {
response = runSynchronous(binary, arguments, timeoutS, interpreter);
} else {
Utils::SynchronousProcess process;
process.setExitCodeInterpreter(interpreter);
connect(this, &ShellCommand::terminate, &process, &Utils::SynchronousProcess::terminate);
if (!d->m_workingDirectory.isEmpty())
process.setWorkingDirectory(d->m_workingDirectory);
process.setProcessEnvironment(processEnvironment());
process.setTimeoutS(timeoutS);
if (d->m_codec)
process.setCodec(d->m_codec);
process.setFlags(processFlags());
// connect stderr to the output window if desired
if (d->m_flags & MergeOutputChannels) {
process.setProcessChannelMode(QProcess::MergedChannels);
} else if (d->m_progressiveOutput
|| !(d->m_flags & SuppressStdErr)) {
process.setStdErrBufferedSignalsEnabled(true);
connect(&process, &Utils::SynchronousProcess::stdErrBuffered,
this, [this, proxy](const QString &text)
{
if (!(d->m_flags & SuppressStdErr))
proxy->appendError(text);
if (d->m_progressiveOutput)
emit errorText(text);
});
}
// connect stdout to the output window if desired
if (d->m_progressParser || d->m_progressiveOutput
|| (d->m_flags & ShowStdOut)) {
process.setStdOutBufferedSignalsEnabled(true);
connect(&process, &Utils::SynchronousProcess::stdOutBuffered,
this, [this, proxy](const QString &text)
{
if (d->m_progressParser)
d->m_progressParser->parseProgress(text);
if (d->m_flags & ShowStdOut)
proxy->append(text);
if (d->m_progressiveOutput) {
emit output(text);
d->m_hadOutput = true;
}
});
}
process.setTimeOutMessageBoxEnabled(true);
// Run!
response = process.run(binary.toString(), arguments);
}
if (!d->m_aborted) {
// Success/Fail message in appropriate window?
if (response.result == Utils::SynchronousProcessResponse::Finished) {
if (d->m_flags & ShowSuccessMessage)
proxy->appendMessage(response.exitMessage(binary.toUserOutput(), timeoutS));
} else if (!(d->m_flags & SuppressFailMessage)) {
proxy->appendError(response.exitMessage(binary.toUserOutput(), timeoutS));
}
}
return response;
}
Utils::SynchronousProcessResponse ShellCommand::runSynchronous(const Utils::FileName &binary,
const QStringList &arguments,
int timeoutS,
Utils::ExitCodeInterpreter *interpreter)
{
Utils::SynchronousProcessResponse response;
QScopedPointer<OutputProxy> proxy(d->m_proxyFactory());
// Set up process
QSharedPointer<QProcess> process = Utils::SynchronousProcess::createProcess(processFlags());
if (!d->m_workingDirectory.isEmpty())
process->setWorkingDirectory(d->m_workingDirectory);
process->setProcessEnvironment(processEnvironment());
if (d->m_flags & MergeOutputChannels)
process->setProcessChannelMode(QProcess::MergedChannels);
// Start
process->start(binary.toString(), arguments, QIODevice::ReadOnly);
process->closeWriteChannel();
if (!process->waitForStarted()) {
response.result = Utils::SynchronousProcessResponse::StartFailed;
return response;
}
// process output
QByteArray stdOut;
QByteArray stdErr;
const bool timedOut =
!Utils::SynchronousProcess::readDataFromProcess(*process.data(), timeoutS,
&stdOut, &stdErr, true);
if (!d->m_aborted) {
if (!stdErr.isEmpty()) {
response.stdErr = Utils::SynchronousProcess::normalizeNewlines(
d->m_codec ? d->m_codec->toUnicode(stdErr) : QString::fromLocal8Bit(stdErr));
if (!(d->m_flags & SuppressStdErr))
proxy->append(response.stdErr);
}
if (!stdOut.isEmpty()) {
response.stdOut = Utils::SynchronousProcess::normalizeNewlines(
d->m_codec ? d->m_codec->toUnicode(stdOut) : QString::fromLocal8Bit(stdOut));
if (d->m_flags & ShowStdOut) {
if (d->m_flags & SilentOutput)
proxy->appendSilently(response.stdOut);
else
proxy->append(response.stdOut);
}
}
}
Utils::ExitCodeInterpreter defaultInterpreter(this);
Utils::ExitCodeInterpreter *currentInterpreter = interpreter ? interpreter : &defaultInterpreter;
// Result
if (timedOut)
response.result = Utils::SynchronousProcessResponse::Hang;
else if (process->exitStatus() != QProcess::NormalExit)
response.result = Utils::SynchronousProcessResponse::TerminatedAbnormally;
else
response.result = currentInterpreter->interpretExitCode(process->exitCode());
return response;
}
bool ShellCommand::runFullySynchronous(const Utils::FileName &binary, const QStringList &arguments,
int timeoutS, QByteArray *outputData, QByteArray *errorData)
{
QTC_ASSERT(!binary.isEmpty(), return false);
QScopedPointer<OutputProxy> proxy(d->m_proxyFactory());
if (!(d->m_flags & SuppressCommandLogging))
proxy->appendCommand(d->m_workingDirectory, binary, arguments);
QProcess process;
process.setWorkingDirectory(d->m_workingDirectory);
process.setProcessEnvironment(d->m_environment);
process.start(binary.toString(), arguments);
process.closeWriteChannel();
if (!process.waitForStarted()) {
if (errorData) {
const QString msg = QString::fromLatin1("Unable to execute \"%1\": %2:")
.arg(binary.toUserOutput(), process.errorString());
*errorData = msg.toLocal8Bit();
}
return false;
}
if (!Utils::SynchronousProcess::readDataFromProcess(process, timeoutS, outputData, errorData, true)) {
if (errorData)
errorData->append(tr("Error: Executable timed out after %1 s.").arg(timeoutS).toLocal8Bit());
Utils::SynchronousProcess::stopProcess(process);
return false;
}
return process.exitStatus() == QProcess::NormalExit && process.exitCode() == 0;
}
const QVariant &ShellCommand::cookie() const
{
return d->m_cookie;
}
void ShellCommand::setCookie(const QVariant &cookie)
{
d->m_cookie = cookie;
}
QTextCodec *ShellCommand::codec() const
{
return d->m_codec;
}
void ShellCommand::setCodec(QTextCodec *codec)
{
d->m_codec = codec;
}
//! Use \a parser to parse progress data from stdout. Command takes ownership of \a parser
void ShellCommand::setProgressParser(ProgressParser *parser)
{
QTC_ASSERT(!d->m_progressParser, return);
d->m_progressParser = parser;
}
void ShellCommand::setProgressiveOutput(bool progressive)
{
d->m_progressiveOutput = progressive;
}
void ShellCommand::setOutputProxyFactory(const std::function<OutputProxy *()> &factory)
{
d->m_proxyFactory = factory;
}
ProgressParser::ProgressParser() :
m_future(0),
m_futureMutex(new QMutex)
{ }
ProgressParser::~ProgressParser()
{
delete m_futureMutex;
}
void ProgressParser::setProgressAndMaximum(int value, int maximum)
{
QMutexLocker lock(m_futureMutex);
if (!m_future)
return;
m_future->setProgressRange(0, maximum);
m_future->setProgressValue(value);
}
void ProgressParser::setFuture(QFutureInterface<void> *future)
{
QMutexLocker lock(m_futureMutex);
m_future = future;
}
} // namespace Utils
/**************************************************************************
**
** Copyright (C) 2015 Brian McGillion and Hugues Delorme
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef UTILS_SHELLCOMMAND_H
#define UTILS_SHELLCOMMAND_H
#include "utils_global.h"
#include <QObject>
#include <functional>
QT_BEGIN_NAMESPACE
class QMutex;
class QStringList;
class QVariant;
class QProcessEnvironment;
template <typename T>
class QFutureInterface;
template <typename T>
class QFuture;
QT_END_NAMESPACE
namespace Utils {
struct SynchronousProcessResponse;
class ExitCodeInterpreter;