bool Upload::upload(const Package &package)
{
if (!m_uploadFiles) {
return true;
}
QProcess ssh;
QStringList arguments;
QString const auth = "*****@*****.**";
arguments << auth;
arguments << "mkdir" << "-p";
QString remoteDir = QString("/home/marble/web/monav/") + targetDir();
arguments << remoteDir;
ssh.start("ssh", arguments);
ssh.waitForFinished(1000 * 60 * 10); // wait up to 10 minutes for mkdir to complete
if (ssh.exitStatus() != QProcess::NormalExit || ssh.exitCode() != 0) {
qDebug() << "Failed to create remote directory " << remoteDir;
Logger::instance().setStatus(package.region.id(), package.region.name(), "error", "Failed to create remote directory: " + ssh.readAllStandardError());
return false;
}
QProcess scp;
arguments.clear();
arguments << package.file.absoluteFilePath();
QString target = remoteDir + "/" + package.file.fileName();
arguments << auth + ":" + target;
scp.start("scp", arguments);
scp.waitForFinished(1000 * 60 * 60 * 12); // wait up to 12 hours for upload to complete
if (scp.exitStatus() != QProcess::NormalExit || scp.exitCode() != 0) {
qDebug() << "Failed to upload " << target;
Logger::instance().setStatus(package.region.id(), package.region.name(), "error", "Failed to upload file: " + scp.readAllStandardError());
return false;
}
return adjustNewstuffFile(package);
}
void tst_QThreadStorage::QTBUG13877_crashOnExit()
{
QProcess process;
#ifdef Q_OS_WIN
# ifdef QT_NO_DEBUG
process.start("release/crashOnExit");
# else
process.start("debug/crashOnExit");
# endif
#else
process.start("./crashOnExit");
#endif
QVERIFY(process.waitForFinished());
QVERIFY(process.exitStatus() != QProcess::CrashExit);
}
void Tmpl::ready()
{
for (QList<TmplExpand>::iterator it = tmpls.begin(); it != tmpls.end(); ++it){
QProcess *p = it->process;
if (p && p->state() == QProcess::NotRunning){
if (p->exitStatus() == QProcess::NormalExit){
it->bReady = true;
p->setReadChannel(QProcess::StandardOutput);
it->res += QString::fromLocal8Bit(p->readAll());
QTimer::singleShot(0, this, SLOT(clear()));
return;
}
}
}
}
// Return the GhostScript version string, or QString::null if it couldn't be retrived.
QString getGSVersion()
{
QStringList args;
args.append(QString("--version").toLocal8Bit());
QString gsExe = getShortPathName(PrefsManager::instance()->ghostscriptExecutable());
QProcess proc;
proc.start(gsExe.toLocal8Bit(), args);
if (proc.waitForStarted(5000))
while (!proc.waitForFinished(5000))
qApp->processEvents();
QString gsVer;
if (proc.exitStatus()==QProcess::NormalExit)
gsVer = proc.readAllStandardOutput();
return gsVer;
}
void FuzzyTester::runGit(const QStringList &arguments, QString *output)
{
QProcess git;
git.start("git", arguments);
if (!git.waitForStarted())
throw TestError("Failed to start git. It is expected to be in the PATH.");
if (!git.waitForFinished(300000) || git.exitStatus() != QProcess::NormalExit) // 5 minutes ought to be enough for everyone
throw TestError(QString::fromLatin1("git failed: %1").arg(git.errorString()));
if (git.exitCode() != 0) {
throw TestError(QString::fromLatin1("git failed: %1")
.arg(QString::fromLocal8Bit(git.readAllStandardError())));
}
if (output)
*output = QString::fromLocal8Bit(git.readAllStandardOutput()).trimmed();
}
int TestBlackboxBase::runQbs(const QbsRunParameters ¶ms)
{
QStringList args;
if (!params.command.isEmpty())
args << params.command;
if (supportsBuildDirectoryOption(params.command)) {
args.append(QLatin1String("-d"));
args.append(params.buildDirectory.isEmpty() ? QLatin1String(".") : params.buildDirectory);
}
args << params.arguments;
if (params.useProfile)
args.append(QLatin1String("profile:") + profileName());
QProcess process;
process.setProcessEnvironment(params.environment);
process.start(qbsExecutableFilePath, args);
const int waitTime = 10 * 60000;
if (!process.waitForStarted() || !process.waitForFinished(waitTime)) {
m_qbsStderr = process.readAllStandardError();
if (!params.expectFailure)
qDebug("%s", qPrintable(process.errorString()));
return -1;
}
m_qbsStderr = process.readAllStandardError();
m_qbsStdout = process.readAllStandardOutput();
sanitizeOutput(&m_qbsStderr);
sanitizeOutput(&m_qbsStdout);
if ((process.exitStatus() != QProcess::NormalExit
|| process.exitCode() != 0) && !params.expectFailure) {
if (!m_qbsStderr.isEmpty())
qDebug("%s", m_qbsStderr.constData());
if (!m_qbsStdout.isEmpty())
qDebug("%s", m_qbsStdout.constData());
}
return process.exitStatus() == QProcess::NormalExit ? process.exitCode() : -1;
}
QString Nepomuk2::OfficeExtractor::textFromFile(const QUrl &fileUrl, const QString &command, QStringList &arguments)
{
arguments << fileUrl.toLocalFile();
// Start a process and read its standard output
QProcess process;
process.setReadChannel(QProcess::StandardOutput);
process.start(command, arguments, QIODevice::ReadOnly);
process.waitForFinished();
if (process.exitStatus() != QProcess::NormalExit || process.exitCode() != 0)
return QString();
else
return QString::fromUtf8(process.readAll());
}
CryptTask::status CryptTask::closeMapper( const QString& p )
{
QString path = p ;
path.replace( "\"","\"\"\"" ) ;
QString e = QString( "%1 -q -d \"%2\"" ).arg( ZULUCRYPTzuluCrypt,path ) ;
QProcess exe ;
exe.start( e ) ;
exe.waitForFinished() ;
int st = exe.exitStatus() ;
exe.close() ;
if( st == 0 ){
return CryptTask::success ;
}else{
return CryptTask::closeMapperFail ;
}
}
RideFile *QuarqFileReader::openRideFile(QFile &file, QStringList &errors, QList<RideFile*>*) const
{
(void) errors;
RideFile *rideFile = new RideFile();
rideFile->setDeviceType("Quarq Qollector");
rideFile->setFileFormat("Quarq ANT+ Files (qla)");
rideFile->setRecIntSecs(1.0);
QuarqParser handler(rideFile);
QProcess *antProcess = getInterpreterProcess( installed_path );
assert(antProcess);
QXmlInputSource source (antProcess);
QXmlSimpleReader reader;
reader.setContentHandler (&handler);
// this could done be a loop to "save memory."
file.open(QIODevice::ReadOnly);
antProcess->write(file.readAll());
antProcess->closeWriteChannel();
antProcess->waitForFinished(-1);
assert(QProcess::NormalExit == antProcess->exitStatus());
assert(0 == antProcess->exitCode());
reader.parse(source);
reader.parseContinue();
QRegExp rideTime("^.*/(\\d\\d\\d\\d)_(\\d\\d)_(\\d\\d)_"
"(\\d\\d)_(\\d\\d)_(\\d\\d)\\.qla$");
if (rideTime.indexIn(file.fileName()) >= 0) {
QDateTime datetime(QDate(rideTime.cap(1).toInt(),
rideTime.cap(2).toInt(),
rideTime.cap(3).toInt()),
QTime(rideTime.cap(4).toInt(),
rideTime.cap(5).toInt(),
rideTime.cap(6).toInt()));
rideFile->setStartTime(datetime);
}
delete antProcess;
return rideFile;
}
bool AutoBarcodeScanner::isJollaCameraRunning() {
QProcess process;
QString cmd = "pidof";
QStringList args("jolla-camera");
process.start(cmd, args);
bool result = false;
if (process.waitForFinished()) {
result = (process.exitStatus() == QProcess::NormalExit &&
process.exitCode() == 0);
}
if (result) {
emit error(AutoBarcodeScanner::JollaCameraRunning);
}
return result;
}
void Pt_WidgetsGallery::executeWidgetsgallery(const QStringList& arguments)
{
QString program = "widgetsgallery";
//execute local binary file
QString sLocalProgram("../../demos/widgetsgallery/widgetsgallery");
if(QFileInfo(sLocalProgram).exists()) {
program = sLocalProgram;
}
QProcess proc;
proc.start(program, arguments);
QVERIFY(proc.waitForStarted());
QVERIFY(proc.waitForFinished());
QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
QCOMPARE(proc.exitCode(), 0);
}
bool PackageInfo::ReadFromFile(QString sName)
{
QProcess procInfo;
procInfo.setReadChannel(QProcess::StandardOutput);
procInfo.start("dpkg-deb", QStringList() << "-f" << sName);
procInfo.waitForFinished(3000);
if (procInfo.exitStatus() == QProcess::NormalExit) {
m_qsFilename = sName;
return ParsePackageInfo(&procInfo);
}
else {
qDebug() << procInfo.readAllStandardError();
}
return false;
}
bool quarqInterpreterInstalled( void ) {
static bool checkedInstallation = false;
static bool installed;
if (!checkedInstallation) {
QString interpreterPath="/usr/local/bin/qollector_interpret/build-";
QStringList executables;
executables << "linux-i386/qollector_interpret";
executables << "osx-ppc-i386/qollector_interpret";
executables << "win32/qollector_interpret.exe";
for ( QStringList::Iterator ex = executables.begin(); ex != executables.end(); ++ex ) {
QProcess *antProcess = getInterpreterProcess( interpreterPath + *ex );
if (NULL == antProcess) {
installed = false;
} else {
antProcess->closeWriteChannel();
antProcess->waitForFinished(-1);
installed=((QProcess::NormalExit == antProcess->exitStatus()) &&
(0 == antProcess->exitCode()));
delete antProcess;
if (installed) {
installed_path = interpreterPath + *ex;
break;
}
}
}
if (!installed)
//std::cerr << "Cannot open qollector_interpret program, available from http://opensource.quarq.us/qollector_interpret." << std::endl;
checkedInstallation = true;
}
return installed;
}
void tst_QCommandLineParser::testVersionOption()
{
#ifdef QT_NO_PROCESS
QSKIP("This test requires QProcess support");
#else
#ifdef Q_OS_WINCE
QSKIP("Reading and writing to a process is not supported on Qt/CE");
#endif
QCoreApplication app(empty_argc, empty_argv);
QProcess process;
process.start("testhelper/qcommandlineparser_test_helper", QStringList() << "0" << "--version");
QVERIFY(process.waitForFinished(5000));
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QString output = process.readAll();
#ifdef Q_OS_WIN
output.replace(QStringLiteral("\r\n"), QStringLiteral("\n"));
#endif
QCOMPARE(output, QString("qcommandlineparser_test_helper 1.0\n"));
#endif // !QT_NO_PROCESS
}
void
YTVideoUrlFetcher::runInitialCheck()
{
QStringList arguments;
arguments << "--version";
QProcess process;
process.start(getYouTubeDLPath(), arguments, QIODevice::ReadOnly);
process.waitForFinished();
if (process.exitStatus() == QProcess::NormalExit &&
process.exitCode() == 0) {
_version_str = process.readAllStandardOutput();
_version_str = _version_str.simplified();
_works = true;
qDebug() << "youtube-dl works, current version:" << _version_str;
} else {
qWarning() << "youtune-dl is non functional:" << process.readAllStandardError();
}
}
static bool runProcess(const QString &binary,
const QStringList &arguments,
QString *errorMessage,
const QString &workingDir = QString(),
const QProcessEnvironment &env = QProcessEnvironment(),
int timeOut = 5000,
QByteArray *stdOut = Q_NULLPTR, QByteArray *stdErr = Q_NULLPTR)
{
QProcess process;
if (!env.isEmpty())
process.setProcessEnvironment(env);
if (!workingDir.isEmpty())
process.setWorkingDirectory(workingDir);
qDebug().noquote().nospace() << "Running: " << QDir::toNativeSeparators(binary)
<< ' ' << arguments.join(QLatin1Char(' '));
process.start(binary, arguments, QIODevice::ReadOnly);
if (!process.waitForStarted()) {
*errorMessage = msgProcessError(process, "Failed to start");
return false;
}
if (!process.waitForFinished(timeOut)) {
*errorMessage = msgProcessError(process, "Timed out");
process.terminate();
if (!process.waitForFinished(300))
process.kill();
return false;
}
if (stdOut)
*stdOut = process.readAllStandardOutput();
if (stdErr)
*stdErr= process.readAllStandardError();
if (process.exitStatus() != QProcess::NormalExit) {
*errorMessage = msgProcessError(process, "Crashed");
return false;
}
if (process.exitCode() != QProcess::NormalExit) {
*errorMessage = msgProcessError(process, "Exit code " + QString::number(process.exitCode()));
return false;
}
return true;
}
bool Job::monav()
{
QString const status = QString("Generating offline routing map from %1 (%2).").arg(osmFile().fileName()).arg(Region::fileSize(osmFile()));
changeStatus(Routing, status);
QStringList arguments;
arguments << "-s=" + m_monavSettings;
arguments << "-i=" + osmFile().absoluteFilePath();
arguments << "-o=" + monavDir().absoluteFilePath();
arguments << "-pi=OpenStreetMap Importer" << "-pro=Contraction Hierarchies";
arguments << "-pg=GPS Grid" << "-di";
arguments << "-dro=" + m_transport;
arguments << "--profile=" + m_profile;
arguments << "-dd" /*<< "-dc"*/;
QProcess monav;
monav.start("monav-preprocessor", arguments);
monav.waitForFinished(1000 * 60 * 60 * 6); // wait up to 6 hours for monav to convert the data
if (monav.exitStatus() == QProcess::NormalExit && monav.exitCode() == 0) {
qDebug() << "Processed osm file for monav";
} else {
qDebug() << "monav exiting with status " << monav.exitCode();
changeStatus(Error, "Routing map conversion failed: " + monav.readAllStandardError());
return false;
}
QFile pluginsFile(monavDir().absoluteFilePath() + "/plugins.ini");
pluginsFile.open(QFile::WriteOnly | QFile::Truncate);
QTextStream pluginsStream(&pluginsFile);
pluginsStream << "[General]\nrouter=Contraction Hierarchies\nrenderer=Mapnik Renderer\ngpsLookup=GPS Grid\naddressLookup=Unicode Tournament Trie\n";
pluginsFile.close();
QFileInfo subdir = QFileInfo(monavDir().absoluteFilePath() + "/routing_" + m_transport.toLower());
if (subdir.exists() && subdir.isDir()) {
QFileInfoList files = QDir(subdir.absoluteFilePath()).entryInfoList(QDir::Files);
foreach(const QFileInfo &file, files) {
if (!QFile::rename(file.absoluteFilePath(), monavDir().absoluteFilePath() + '/' + file.fileName())) {
changeStatus(Error, "Unable to move monav files to target directory.");
return false;
}
}
QDir("/").rmdir(subdir.absoluteFilePath());
} else {
bool Upload::uploadNewstuff()
{
QTemporaryFile outFile(QDir::tempPath() + "/monav-maps-out-XXXXXX.xml");
outFile.open();
QTextStream outStream(&outFile);
outStream << m_xml.toString(2);
outStream.flush();
QProcess scp;
QStringList arguments;
arguments << outFile.fileName();
arguments << "[email protected]:/home/marble/web/newstuff/maps-monav.xml";
scp.start("scp", arguments);
scp.waitForFinished(1000 * 60 * 60 * 12); // wait up to 12 hours for upload to complete
if (scp.exitStatus() != QProcess::NormalExit || scp.exitCode() != 0) {
qDebug() << "Failed to upload " << outFile.fileName() << ": " << scp.readAllStandardError();
return false;
}
return true;
}
/* forks and executes ctags to rebuild a tags file
* storing cache_value in the tags file */
bool InitCompletion::buildTagsFile(long cache_value, const QString &parsedText)
{
QString pathList = includesPathList(parsedText);
QFile includesListFile(tagsIncludesPath);
if (includesListFile.open(QIODevice::WriteOnly | QIODevice::Text))
{
includesListFile.write (pathList.toLocal8Bit());
includesListFile.close();
/* save the cache information in the tags file */
QFile tags(tagsFilePath);
if (tags.open(QIODevice::WriteOnly | QIODevice::Text))
{
QString head = "!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;\" to lines/" NEW_LINE
"!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/" NEW_LINE
"!_TAG_PROGRAM_AUTHOR Darren Hiebert /[email protected]/" NEW_LINE
"!_TAG_PROGRAM_NAME Exuberant Ctags //" NEW_LINE
"!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/" NEW_LINE
"!_TAG_PROGRAM_VERSION 5.5.4 //" NEW_LINE
"!_TAG_CACHE\t" + QString::number(cache_value) + NEW_LINE;
tags.write(head.toLocal8Bit());
tags.close();
}
QString command = ctagsCmdPath + " -f \"" + tagsFilePath +
"\" --append --language-force=c++ --fields=afiKmsSzn --c++-kinds=cdefgmnpstuvx -L \""
+ tagsIncludesPath +'\"';
// I don't process any user input, so system() should be safe enough
QProcess ctags;
ctags.execute(command);
includesListFile.remove();
if (ctags.exitStatus() == QProcess::NormalExit)
return true;
}
return false;
}
static QString RunApp(const QString &execPath, const QString &execParam, const QString &execPipeIn="") {
QString outPipePath = Xapi::TmpFilePath("pipeOut");
QProcess app;
app.setStandardInputFile(execPipeIn);
app.setStandardOutputFile(outPipePath);
app.setStandardErrorFile(outPipePath);
app.start(execPath + " " + execParam);
app.waitForFinished();
if (QProcess::NormalExit != app.exitStatus())
qDebug()<<app.error()<<app.errorString()<<app.state();
QFile locale(outPipePath);
if (!locale.open(QIODevice::ReadOnly)) {
qDebug()<<"Open output pipe Fialed!"<<outPipePath;
return "";
}
QTextStream localets(&locale);
QString outUtf8PipePath = Xapi::TmpFilePath("utf8pipeOut");
QFile utf8(outUtf8PipePath);
if (!utf8.open(QIODevice::WriteOnly)) {
qDebug()<<"Open utf8 output pipe Fialed!"<<outUtf8PipePath;
return "";
}
QTextStream utf8ts(&utf8);
utf8ts.setCodec("utf8");
utf8ts<<localets.readAll();
locale.close();
utf8.close();
utf8.open(QIODevice::ReadOnly);
QString ret = QString(utf8.readAll());
utf8.close();
locale.remove();
utf8.remove();
return ret;
}
bool writeImage(QString devicePath, QString deviceImage, QObject* caller)
{
devicePath.replace(" ", "\\ ");
deviceImage.replace(" ", "\\ ");
QString aScript ="do shell script \"dd if="+ deviceImage + " of="+ devicePath +" bs=1m conv=sync && sync\" with administrator privileges";
QString osascript = "/usr/bin/osascript";
QStringList processArguments;
processArguments << "-l" << "AppleScript";
QProcess p;
p.setEnvironment(QStringList() << "LANG=C");
utils::writeLog("going to start osa");
p.start(osascript);
p.waitForStarted();
utils::writeLog("pasting admin script to process " + aScript);
p.write(aScript.toUtf8());
p.closeWriteChannel();
utils::writeLog("waiting for finish");
p.waitForReadyRead(-1);
p.waitForFinished(-1);
utils::writeLog("osa claims to be done...collect output and verify");
QByteArray stdoutArray = p.readAllStandardOutput();
QByteArray stderrArray = p.readAllStandardError();
int exitCode = p.exitCode();
if (exitCode == 0 && p.exitStatus() == QProcess::NormalExit) {
utils::writeLog("Imaging was successful");
return true;
}
else
{
utils::writeLog("Imaging failed!");
utils::writeLog("Messages are:");
utils::writeLog("\t stdout: " + QString(stdoutArray));
utils::writeLog("\t stderr: " + QString(stderrArray));
return false;
}
}
static bool RunOBJDUMP( QByteArray &output )
{
QProcess p;
p.setProcessChannelMode( QProcess::MergedChannels );
QStringList args = QStringList() << "-D" << "--section=.text" << objFileName;
QString prog( QDir::currentPath() + "/tools/objdump" );
p.start( prog, args );
if( !p.waitForFinished( -1 ) )
{
qDebug() << "failed to start" << prog;
return false;
}
output = p.readAllStandardOutput();
if( p.exitStatus() != QProcess::NormalExit || p.exitCode() )
{
qDebug() << prog << "didn\'t run right:" << output;
return false;
}
return true;
}
bool Upload::deleteRemoteFile(const QString &filename)
{
if (filename.isEmpty()) {
return true;
}
if (!filename.startsWith("/home/marble/")) {
return false;
}
QProcess ssh;
QStringList arguments;
arguments << "*****@*****.**" << "rm" << filename;
ssh.start("ssh", arguments);
ssh.waitForFinished(1000 * 60 * 10); // wait up to 10 minutes for rm to complete
if (ssh.exitStatus() != QProcess::NormalExit || ssh.exitCode() != 0) {
qDebug() << "Failed to delete remote file " << filename;
return false;
}
return true;
}
bool VcsCommand::runFullySynchronous(const QStringList &arguments, int timeoutMS,
QByteArray *outputData, QByteArray *errorData)
{
if (d->m_binaryPath.isEmpty())
return false;
OutputProxy outputProxy;
if (!(d->m_flags & VcsBasePlugin::SuppressCommandLogging))
emit outputProxy.appendCommand(d->m_workingDirectory, d->m_binaryPath, arguments);
// TODO tell the document manager about expected repository changes
// if (d->m_flags & ExpectRepoChanges)
// Core::DocumentManager::expectDirectoryChange(workingDirectory);
QProcess process;
process.setWorkingDirectory(d->m_workingDirectory);
process.setProcessEnvironment(d->m_environment);
process.start(d->m_binaryPath.toString(), arguments);
process.closeWriteChannel();
if (!process.waitForStarted()) {
if (errorData) {
const QString msg = QString::fromLatin1("Unable to execute \"%1\": %2:")
.arg(d->m_binaryPath.toUserOutput(), process.errorString());
*errorData = msg.toLocal8Bit();
}
return false;
}
if (!Utils::SynchronousProcess::readDataFromProcess(process, timeoutMS, outputData, errorData, true)) {
if (errorData)
errorData->append(tr("Error: Executable timed out after %1s.").arg(timeoutMS / 1000).toLocal8Bit());
Utils::SynchronousProcess::stopProcess(process);
return false;
}
emitRepositoryChanged();
return process.exitStatus() == QProcess::NormalExit && process.exitCode() == 0;
}
void ApbsDialog::runApbs()
{
saveInputFile("apbs.in");
// run apbs
QStringList arguments;
arguments.append("apbs.in");
QProcess process;
process.start("apbs", arguments);
// FIXME: show progress dialog
process.waitForFinished();
if (process.exitStatus() == QProcess::NormalExit) {
m_cubeFileName = "pot-PE0.dx";
ApbsOutputDialog dialog(this);
connect(&dialog, SIGNAL(accepted()), this, SLOT(accept()));
int code = dialog.exec();
if (code == QDialog::Accepted) {
m_loadStructureFile = dialog.loadStructureFile();
m_loadCubeFile = dialog.loadCubeFile();
}
else {
m_loadStructureFile = false;
m_loadCubeFile = false;
}
}
else {
m_loadStructureFile = false;
m_loadCubeFile = false;
QMessageBox::critical(this, tr("Error"),
tr("Error running APBS: %1").arg(
process.readAllStandardError().constData()));
}
}
Utils::Port IosSimulator::nextPort() const
{
for (int i = 0; i < 100; ++i) {
// use qrand instead?
if (++m_lastPort >= Constants::IOS_SIMULATOR_PORT_END)
m_lastPort = Constants::IOS_SIMULATOR_PORT_START;
QProcess portVerifier;
// this is a bit too broad (it does not check just listening sockets, but also connections
// to that port from this computer)
portVerifier.start(QLatin1String("lsof"), QStringList() << QLatin1String("-n")
<< QLatin1String("-P") << QLatin1String("-i")
<< QString::fromLatin1(":%1").arg(m_lastPort));
if (!portVerifier.waitForStarted())
break;
portVerifier.closeWriteChannel();
if (!portVerifier.waitForFinished() && portVerifier.state() == QProcess::Running)
break;
if (portVerifier.exitStatus() != QProcess::NormalExit
|| portVerifier.exitCode() != 0)
break;
}
return Utils::Port(m_lastPort);
}
void tst_QCommandLineParser::testQuoteEscaping()
{
#ifdef QT_NO_PROCESS
QSKIP("This test requires QProcess support");
#else
QCoreApplication app(empty_argc, empty_argv);
QProcess process;
process.start("testhelper/qcommandlineparser_test_helper", QStringList() <<
QString::number(QCommandLineParser::ParseAsCompactedShortOptions) <<
"\\\\server\\path" <<
"-DKEY1=\"VALUE1\""
"-DQTBUG-15379=C:\\path\\'file.ext" <<
"-DQTBUG-30628=C:\\temp\\'file'.ext");
QVERIFY(process.waitForFinished(5000));
QCOMPARE(process.exitStatus(), QProcess::NormalExit);
QString output = process.readAll();
QVERIFY2(!output.contains("ERROR"), qPrintable(output));
QVERIFY2(output.contains("\\\\server\\path"), qPrintable(output));
QVERIFY2(output.contains("KEY1=\"VALUE1\""), qPrintable(output));
QVERIFY2(output.contains("QTBUG-15379=C:\\path\\'file.ext"), qPrintable(output));
QVERIFY2(output.contains("QTBUG-30628=C:\\temp\\'file'.ext"), qPrintable(output));
#endif // !QT_NO_PROCESS
}
void SqliteProcess::start(const QStringList & commands, const QStringList & options)
{
QProcess p;
if (!m_stdout.isNull())
p.setStandardOutputFile(m_stdout);
QStringList list = QStringList() << options << m_mainDbPath << commands;
qDebug() << "Running " << SQLITE_BINARY << " with args: " << list;
qDebug() << QString(" %1 %2").arg(SQLITE_BINARY).arg(list.join(" "));
p.start(SQLITE_BINARY, list);
if (!p.waitForStarted() || !p.waitForFinished(-1) || (p.exitStatus() != QProcess::NormalExit))
{
m_success = false;
switch (p.error())
{
case (QProcess::FailedToStart) :
m_error = tr("The process failed to start. Either the invoked program is missing, or you may have insufficient permissions to invoke the program.");
break;
case (QProcess::Crashed) :
m_error = tr("The process crashed some time after starting successfully.");
break;
case (QProcess::WriteError) :
m_error = tr("An error occurred when attempting to write to the process. For example, the process may not be running, or it may have closed its input channel.");
break;
case (QProcess::ReadError):
m_error = tr("An error occurred when attempting to read from the process. For example, the process may not be running.");
break;
default:
m_error = tr("An unknown error occurred.");
}
}
else
m_success = true;
m_stderr = QString(p.readAllStandardError());
m_stdout = QString(p.readAllStandardOutput());
}
static bool runHelper(const QString &program, const QStringList &arguments, QByteArray *errorMessage)
{
QProcess process;
process.setReadChannelMode(QProcess::ForwardedChannels);
process.start(program, arguments);
if (!process.waitForStarted()) {
*errorMessage = "Unable to start '" + program.toLocal8Bit() + " ': "
+ process.errorString().toLocal8Bit();
return false;
}
// Windows: Due to implementation changes, the event loop needs
// to be spun since we ourselves also need to answer the
// WM_DRAWCLIPBOARD message as we are in the chain of clipboard
// viewers.
bool running = true;
for (int i = 0; i < 60 && running; ++i) {
QGuiApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
if (process.waitForFinished(500))
running = false;
}
if (running) {
process.kill();
*errorMessage = "Timeout running '" + program.toLocal8Bit() + '\'';
return false;
}
if (process.exitStatus() != QProcess::NormalExit) {
*errorMessage = "Process '" + program.toLocal8Bit() + "' crashed.";
return false;
}
if (process.exitCode()) {
*errorMessage = "Process '" + program.toLocal8Bit() + "' returns "
+ QByteArray::number(process.exitCode());
return false;
}
return true;
}
bool startCreatorAsDebugger(bool asClient, QString *errorMessage)
{
const QString dir = QApplication::applicationDirPath();
const QString binary = dir + QLatin1Char('/') + QLatin1String(creatorBinaryC);
QStringList args;
// Send to running Creator: Unstable with directly linked CDB engine.
if (asClient)
args << QLatin1String("-client");
args << QLatin1String("-wincrashevent")
<< QString::fromLatin1("%1:%2").arg(argWinCrashEvent).arg(argProcessId);
if (debug)
qDebug() << binary << args;
QProcess p;
p.setWorkingDirectory(dir);
QTime executionTime;
executionTime.start();
p.start(binary, args, QIODevice::NotOpen);
if (!p.waitForStarted()) {
*errorMessage = QString::fromLatin1("Unable to start %1!").arg(binary);
return false;
}
// Short execution time: indicates that -client was passed on attach to
// another running instance of Qt Creator. Keep alive as long as user
// does not close the process. If that fails, try to launch 2nd instance.
const bool waitResult = p.waitForFinished(-1);
const bool ranAsClient = asClient && (executionTime.elapsed() < 10000);
if (waitResult && p.exitStatus() == QProcess::NormalExit && ranAsClient) {
if (p.exitCode() == 0) {
waitForProcess(argProcessId);
} else {
errorMessage->clear();
return startCreatorAsDebugger(false, errorMessage);
}
}
return true;
}
