ground/gcs/src/libs/utils/synchronousprocess.cpp

   1 /**
   2  ******************************************************************************
   3  *
   4  * @file       synchronousprocess.cpp
   5  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
   6  *             Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
   7  * @brief
   8  * @see        The GNU Public License (GPL) Version 3
   9  * @defgroup
  10  * @{
  11  *
  12  *****************************************************************************/
  13 /*
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful, but
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  21  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  22  * for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License along
  25  * with this program; if not, write to the Free Software Foundation, Inc.,
  26  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  27  */
  28
  29 #include "synchronousprocess.h"
  30
  31 #include <QtCore/QDebug>
  32 #include <QtCore/QTimer>
  33 #include <QtCore/QEventLoop>
  34 #include <QtCore/QTextCodec>
  35 #include <QtCore/QFileInfo>
  36 #include <QtCore/QDir>
  37
  38 #include <QtWidgets/QApplication>
  39
  40 #include <limits.h>
  41
  42 enum { debug = 0 };
  43
  44 enum { defaultMaxHangTimerCount = 10 };
  45
  46 namespace Utils {
  47 // ----------- SynchronousProcessResponse
  48 SynchronousProcessResponse::SynchronousProcessResponse() :
  49     result(StartFailed),
  50     exitCode(-1)
  51 {}
  52
  53 void SynchronousProcessResponse::clear()
  54 {
  55     result   = StartFailed;
  56     exitCode = -1;
  57     stdOut.clear();
  58     stdErr.clear();
  59 }
  60
  61 QTCREATOR_UTILS_EXPORT QDebug operator<<(QDebug str, const SynchronousProcessResponse & r)
  62 {
  63     QDebug nsp = str.nospace();
  64
  65     nsp << "SynchronousProcessResponse: result=" << r.result << " ex=" << r.exitCode << '\n'
  66         << r.stdOut.size() << " bytes stdout, stderr=" << r.stdErr << '\n';
  67     return str;
  68 }
  69
  70 // Data for one channel buffer (stderr/stdout)
  71 struct ChannelBuffer {
  72     ChannelBuffer();
  73     void clearForRun();
  74     QByteArray linesRead();
  75
  76     QByteArray data;
  77     bool firstData;
  78     bool bufferedSignalsEnabled;
  79     bool firstBuffer;
  80     int  bufferPos;
  81 };
  82
  83 ChannelBuffer::ChannelBuffer() :
  84     firstData(true),
  85     bufferedSignalsEnabled(false),
  86     firstBuffer(true),
  87     bufferPos(0)
  88 {}
  89
  90 void ChannelBuffer::clearForRun()
  91 {
  92     firstData   = true;
  93     firstBuffer = true;
  94     bufferPos   = 0;
  95 }
  96
  97 /* Check for complete lines read from the device and return them, moving the
  98  * buffer position. This is based on the assumption that '\n' is the new line
  99  * marker in any sane codec. */
 100 QByteArray ChannelBuffer::linesRead()
 101 {
 102     // Any new lines?
 103     const int lastLineIndex = data.lastIndexOf('\n');
 104
 105     if (lastLineIndex == -1 || lastLineIndex <= bufferPos) {
 106         return QByteArray();
 107     }
 108     const int nextBufferPos = lastLineIndex + 1;
 109     const QByteArray lines  = data.mid(bufferPos, nextBufferPos - bufferPos);
 110     bufferPos = nextBufferPos;
 111     return lines;
 112 }
 113
 114 // ----------- SynchronousProcessPrivate
 115 struct SynchronousProcessPrivate {
 116     SynchronousProcessPrivate();
 117     void       clearForRun();
 118
 119     QTextCodec *m_stdOutCodec;
 120     QProcess   m_process;
 121     QTimer     m_timer;
 122     QEventLoop m_eventLoop;
 123     SynchronousProcessResponse m_result;
 124     int  m_hangTimerCount;
 125     int  m_maxHangTimerCount;
 126     bool m_startFailure;
 127
 128     ChannelBuffer m_stdOut;
 129     ChannelBuffer m_stdErr;
 130 };
 131
 132 SynchronousProcessPrivate::SynchronousProcessPrivate() :
 133     m_stdOutCodec(0),
 134     m_hangTimerCount(0),
 135     m_maxHangTimerCount(defaultMaxHangTimerCount),
 136     m_startFailure(false)
 137 {}
 138
 139 void SynchronousProcessPrivate::clearForRun()
 140 {
 141     m_hangTimerCount = 0;
 142     m_stdOut.clearForRun();
 143     m_stdErr.clearForRun();
 144     m_result.clear();
 145     m_startFailure = false;
 146 }
 147
 148 // ----------- SynchronousProcess
 149 SynchronousProcess::SynchronousProcess() :
 150     m_d(new SynchronousProcessPrivate)
 151 {
 152     m_d->m_timer.setInterval(1000);
 153     connect(&m_d->m_timer, SIGNAL(timeout()), this, SLOT(slotTimeout()));
 154     connect(&m_d->m_process, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(finished(int, QProcess::ExitStatus)));
 155     connect(&m_d->m_process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(error(QProcess::ProcessError)));
 156     connect(&m_d->m_process, SIGNAL(readyReadStandardOutput()),
 157             this, SLOT(stdOutReady()));
 158     connect(&m_d->m_process, SIGNAL(readyReadStandardError()),
 159             this, SLOT(stdErrReady()));
 160 }
 161
 162 SynchronousProcess::~SynchronousProcess()
 163 {
 164     delete m_d;
 165 }
 166
 167 void SynchronousProcess::setTimeout(int timeoutMS)
 168 {
 169     if (timeoutMS >= 0) {
 170         m_d->m_maxHangTimerCount = qMax(2, timeoutMS / 1000);
 171     } else {
 172         m_d->m_maxHangTimerCount = INT_MAX;
 173     }
 174 }
 175
 176 int SynchronousProcess::timeout() const
 177 {
 178     return m_d->m_maxHangTimerCount == INT_MAX ? -1 : 1000 * m_d->m_maxHangTimerCount;
 179 }
 180
 181 void SynchronousProcess::setStdOutCodec(QTextCodec *c)
 182 {
 183     m_d->m_stdOutCodec = c;
 184 }
 185
 186 QTextCodec *SynchronousProcess::stdOutCodec() const
 187 {
 188     return m_d->m_stdOutCodec;
 189 }
 190
 191 bool SynchronousProcess::stdOutBufferedSignalsEnabled() const
 192 {
 193     return m_d->m_stdOut.bufferedSignalsEnabled;
 194 }
 195
 196 void SynchronousProcess::setStdOutBufferedSignalsEnabled(bool v)
 197 {
 198     m_d->m_stdOut.bufferedSignalsEnabled = v;
 199 }
 200
 201 bool SynchronousProcess::stdErrBufferedSignalsEnabled() const
 202 {
 203     return m_d->m_stdErr.bufferedSignalsEnabled;
 204 }
 205
 206 void SynchronousProcess::setStdErrBufferedSignalsEnabled(bool v)
 207 {
 208     m_d->m_stdErr.bufferedSignalsEnabled = v;
 209 }
 210
 211 QStringList SynchronousProcess::environment() const
 212 {
 213     return m_d->m_process.environment();
 214 }
 215
 216 void SynchronousProcess::setEnvironment(const QStringList &e)
 217 {
 218     m_d->m_process.setEnvironment(e);
 219 }
 220
 221 void SynchronousProcess::setWorkingDirectory(const QString &workingDirectory)
 222 {
 223     m_d->m_process.setWorkingDirectory(workingDirectory);
 224 }
 225
 226 QString SynchronousProcess::workingDirectory() const
 227 {
 228     return m_d->m_process.workingDirectory();
 229 }
 230
 231 QProcess::ProcessChannelMode SynchronousProcess::processChannelMode() const
 232 {
 233     return m_d->m_process.processChannelMode();
 234 }
 235
 236 void SynchronousProcess::setProcessChannelMode(QProcess::ProcessChannelMode m)
 237 {
 238     m_d->m_process.setProcessChannelMode(m);
 239 }
 240
 241 SynchronousProcessResponse SynchronousProcess::run(const QString &binary,
 242                                                    const QStringList &args)
 243 {
 244     if (debug) {
 245         qDebug() << '>' << Q_FUNC_INFO << binary << args;
 246     }
 247
 248     m_d->clearForRun();
 249
 250     // On Windows, start failure is triggered immediately if the
 251     // executable cannot be found in the path. Do not start the
 252     // event loop in that case.
 253     m_d->m_process.start(binary, args, QIODevice::ReadOnly);
 254     if (!m_d->m_startFailure) {
 255         m_d->m_timer.start();
 256         QApplication::setOverrideCursor(Qt::WaitCursor);
 257         m_d->m_eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
 258         if (m_d->m_result.result == SynchronousProcessResponse::Finished || m_d->m_result.result == SynchronousProcessResponse::FinishedError) {
 259             processStdOut(false);
 260             processStdErr(false);
 261         }
 262
 263         m_d->m_result.stdOut = convertStdOut(m_d->m_stdOut.data);
 264         m_d->m_result.stdErr = convertStdErr(m_d->m_stdErr.data);
 265
 266         m_d->m_timer.stop();
 267         QApplication::restoreOverrideCursor();
 268     }
 269
 270     if (debug) {
 271         qDebug() << '<' << Q_FUNC_INFO << binary << m_d->m_result;
 272     }
 273     return m_d->m_result;
 274 }
 275
 276 void SynchronousProcess::slotTimeout()
 277 {
 278     if (++m_d->m_hangTimerCount > m_d->m_maxHangTimerCount) {
 279         if (debug) {
 280             qDebug() << Q_FUNC_INFO << "HANG detected, killing";
 281         }
 282         m_d->m_process.kill();
 283         m_d->m_result.result = SynchronousProcessResponse::Hang;
 284     } else {
 285         if (debug) {
 286             qDebug() << Q_FUNC_INFO << m_d->m_hangTimerCount;
 287         }
 288     }
 289 }
 290
 291 void SynchronousProcess::finished(int exitCode, QProcess::ExitStatus e)
 292 {
 293     if (debug) {
 294         qDebug() << Q_FUNC_INFO << exitCode << e;
 295     }
 296     m_d->m_hangTimerCount = 0;
 297     switch (e) {
 298     case QProcess::NormalExit:
 299         m_d->m_result.result   = exitCode ? SynchronousProcessResponse::FinishedError : SynchronousProcessResponse::Finished;
 300         m_d->m_result.exitCode = exitCode;
 301         break;
 302     case QProcess::CrashExit:
 303         // Was hang detected before and killed?
 304         if (m_d->m_result.result != SynchronousProcessResponse::Hang) {
 305             m_d->m_result.result = SynchronousProcessResponse::TerminatedAbnormally;
 306         }
 307         m_d->m_result.exitCode = -1;
 308         break;
 309     }
 310     m_d->m_eventLoop.quit();
 311 }
 312
 313 void SynchronousProcess::error(QProcess::ProcessError e)
 314 {
 315     m_d->m_hangTimerCount = 0;
 316     if (debug) {
 317         qDebug() << Q_FUNC_INFO << e;
 318     }
 319     // Was hang detected before and killed?
 320     if (m_d->m_result.result != SynchronousProcessResponse::Hang) {
 321         m_d->m_result.result = SynchronousProcessResponse::StartFailed;
 322     }
 323     m_d->m_startFailure = true;
 324     m_d->m_eventLoop.quit();
 325 }
 326
 327 void SynchronousProcess::stdOutReady()
 328 {
 329     m_d->m_hangTimerCount = 0;
 330     processStdOut(true);
 331 }
 332
 333 void SynchronousProcess::stdErrReady()
 334 {
 335     m_d->m_hangTimerCount = 0;
 336     processStdErr(true);
 337 }
 338
 339 QString SynchronousProcess::convertStdErr(const QByteArray &ba)
 340 {
 341     return QString::fromLocal8Bit(ba.constData(), ba.size()).remove(QLatin1Char('\r'));
 342 }
 343
 344 QString SynchronousProcess::convertStdOut(const QByteArray &ba) const
 345 {
 346     QString stdOut = m_d->m_stdOutCodec ? m_d->m_stdOutCodec->toUnicode(ba) : QString::fromLocal8Bit(ba.constData(), ba.size());
 347
 348     return stdOut.remove(QLatin1Char('\r'));
 349 }
 350
 351 void SynchronousProcess::processStdOut(bool emitSignals)
 352 {
 353     // Handle binary data
 354     const QByteArray ba = m_d->m_process.readAllStandardOutput();
 355
 356     if (debug > 1) {
 357         qDebug() << Q_FUNC_INFO << emitSignals << ba;
 358     }
 359     if (!ba.isEmpty()) {
 360         m_d->m_stdOut.data += ba;
 361         if (emitSignals) {
 362             // Emit binary signals
 363             emit stdOut(ba, m_d->m_stdOut.firstData);
 364             m_d->m_stdOut.firstData = false;
 365             // Buffered. Emit complete lines?
 366             if (m_d->m_stdOut.bufferedSignalsEnabled) {
 367                 const QByteArray lines = m_d->m_stdOut.linesRead();
 368                 if (!lines.isEmpty()) {
 369                     emit stdOutBuffered(convertStdOut(lines), m_d->m_stdOut.firstBuffer);
 370                     m_d->m_stdOut.firstBuffer = false;
 371                 }
 372             }
 373         }
 374     }
 375 }
 376
 377 void SynchronousProcess::processStdErr(bool emitSignals)
 378 {
 379     // Handle binary data
 380     const QByteArray ba = m_d->m_process.readAllStandardError();
 381
 382     if (debug > 1) {
 383         qDebug() << Q_FUNC_INFO << emitSignals << ba;
 384     }
 385     if (!ba.isEmpty()) {
 386         m_d->m_stdErr.data += ba;
 387         if (emitSignals) {
 388             // Emit binary signals
 389             emit stdErr(ba, m_d->m_stdErr.firstData);
 390             m_d->m_stdErr.firstData = false;
 391             if (m_d->m_stdErr.bufferedSignalsEnabled) {
 392                 // Buffered. Emit complete lines?
 393                 const QByteArray lines = m_d->m_stdErr.linesRead();
 394                 if (!lines.isEmpty()) {
 395                     emit stdErrBuffered(convertStdErr(lines), m_d->m_stdErr.firstBuffer);
 396                     m_d->m_stdErr.firstBuffer = false;
 397                 }
 398             }
 399         }
 400     }
 401 }
 402
 403 // Path utilities
 404
 405 enum  OS_Type { OS_Mac, OS_Windows, OS_Unix };
 406
 407 #ifdef Q_OS_WIN
 408 static const OS_Type pathOS = OS_Windows;
 409 #else
 410 #  ifdef Q_OS_MAC
 411 static const OS_Type pathOS = OS_Mac;
 412 #  else
 413 static const OS_Type pathOS = OS_Unix;
 414 #  endif
 415 #endif
 416
 417 // Locate a binary in a directory, applying all kinds of
 418 // extensions the operating system supports.
 419 static QString checkBinary(const QDir &dir, const QString &binary)
 420 {
 421     // naive UNIX approach
 422     const QFileInfo info(dir.filePath(binary));
 423
 424     if (info.isFile() && info.isExecutable()) {
 425         return info.absoluteFilePath();
 426     }
 427
 428     // Does the OS have some weird extension concept or does the
 429     // binary have a 3 letter extension?
 430     if (pathOS == OS_Unix) {
 431         return QString();
 432     }
 433     const int dotIndex = binary.lastIndexOf(QLatin1Char('.'));
 434     if (dotIndex != -1 && dotIndex == binary.size() - 4) {
 435         return QString();
 436     }
 437
 438     switch (pathOS) {
 439     case OS_Unix:
 440         break;
 441     case OS_Windows:
 442     {
 443         static const char *windowsExtensions[] = { ".cmd", ".bat", ".exe", ".com" };
 444         // Check the Windows extensions using the order
 445         const int windowsExtensionCount = sizeof(windowsExtensions) / sizeof(const char *);
 446         for (int e = 0; e < windowsExtensionCount; e++) {
 447             const QFileInfo windowsBinary(dir.filePath(binary + QLatin1String(windowsExtensions[e])));
 448             if (windowsBinary.isFile() && windowsBinary.isExecutable()) {
 449                 return windowsBinary.absoluteFilePath();
 450             }
 451         }
 452     }
 453     break;
 454     case OS_Mac:
 455     {
 456         // Check for Mac app folders
 457         const QFileInfo appFolder(dir.filePath(binary + QLatin1String(".app")));
 458         if (appFolder.isDir()) {
 459             QString macBinaryPath = appFolder.absoluteFilePath();
 460             macBinaryPath += QLatin1String("/Contents/MacOS/");
 461             macBinaryPath += binary;
 462             const QFileInfo macBinary(macBinaryPath);
 463             if (macBinary.isFile() && macBinary.isExecutable()) {
 464                 return macBinary.absoluteFilePath();
 465             }
 466         }
 467     }
 468     break;
 469     }
 470     return QString();
 471 }
 472
 473 QString SynchronousProcess::locateBinary(const QString &path, const QString &binary)
 474 {
 475     // Absolute file?
 476     const QFileInfo absInfo(binary);
 477
 478     if (absInfo.isAbsolute()) {
 479         return checkBinary(absInfo.dir(), absInfo.fileName());
 480     }
 481
 482     // Windows finds binaries  in the current directory
 483     if (pathOS == OS_Windows) {
 484         const QString currentDirBinary = checkBinary(QDir::current(), binary);
 485         if (!currentDirBinary.isEmpty()) {
 486             return currentDirBinary;
 487         }
 488     }
 489
 490     const QStringList paths = path.split(pathSeparator());
 491     if (paths.empty()) {
 492         return QString();
 493     }
 494     const QStringList::const_iterator cend = paths.constEnd();
 495     for (QStringList::const_iterator it = paths.constBegin(); it != cend; ++it) {
 496         const QDir dir(*it);
 497         const QString rc = checkBinary(dir, binary);
 498         if (!rc.isEmpty()) {
 499             return rc;
 500         }
 501     }
 502     return QString();
 503 }
 504
 505 QString SynchronousProcess::locateBinary(const QString &binary)
 506 {
 507     const QByteArray path = qgetenv("PATH");
 508
 509     return locateBinary(QString::fromLocal8Bit(path), binary);
 510 }
 511
 512 QChar SynchronousProcess::pathSeparator()
 513 {
 514     if (pathOS == OS_Windows) {
 515         return QLatin1Char(';');
 516     }
 517     return QLatin1Char(':');
 518 }
 519 } // namespace Utils