src/myprocess.cpp

   1 /*
   2         Description: interface to sync and async external program execution
   3
   4         Author: Marco Costalba (C) 2005-2007
   5
   6         Copyright: See COPYING file that comes with this distribution
   7
   8 */
   9 #include <QApplication>
  10 #include <QTime>
  11 #include "exceptionmanager.h"
  12 #include "common.h"
  13 #include "domain.h"
  14 #include "myprocess.h"
  15
  16 MyProcess::MyProcess(QObject *go, Git* g, const QString& wd, bool err) : QProcess(g) {
  17
  18         guiObject = go;
  19         git = g;
  20         workDir = wd;
  21         runOutput = NULL;
  22         receiver = NULL;
  23         errorReportingEnabled = err;
  24         canceling = async = isWinShell = isErrorExit = false;
  25 }
  26
  27 bool MyProcess::runAsync(SCRef rc, QObject* rcv, SCRef buf) {
  28
  29         async = true;
  30         runCmd = rc;
  31         receiver = rcv;
  32         setupSignals();
  33         if (!launchMe(runCmd, buf))
  34                 return false; // caller will delete us
  35
  36         return true;
  37 }
  38
  39 bool MyProcess::runSync(SCRef rc, QByteArray* ro, QObject* rcv, SCRef buf) {
  40
  41         async = false;
  42         runCmd = rc;
  43         runOutput = ro;
  44         receiver = rcv;
  45         if (runOutput)
  46                 runOutput->clear();
  47
  48         setupSignals();
  49         if (!launchMe(runCmd, buf))
  50                 return false;
  51
  52         QTime t;
  53         t.start();
  54
  55         busy = true; // we have to wait here until we exit
  56
  57         while (busy) {
  58                 waitForFinished(20); // suspend 20ms to let OS reschedule
  59
  60                 if (t.elapsed() > 200) {
  61                         EM_PROCESS_EVENTS;
  62                         t.restart();
  63                 }
  64         }
  65         return !isErrorExit;
  66 }
  67
  68 void MyProcess::setupSignals() {
  69
  70         connect(git, SIGNAL(cancelAllProcesses()),
  71                 this, SLOT(on_cancel()));
  72
  73         connect(this, SIGNAL(readyReadStandardOutput()),
  74                 this, SLOT(on_readyReadStandardOutput()));
  75
  76         connect(this, SIGNAL(finished(int, QProcess::ExitStatus)),
  77                 this, SLOT(on_finished(int, QProcess::ExitStatus)));
  78
  79         if (receiver) {
  80
  81                 connect(this, SIGNAL(readyReadStandardError ()),
  82                         this, SLOT(on_readyReadStandardError()));
  83
  84                 connect(this, SIGNAL(procDataReady(const QByteArray&)),
  85                         receiver, SLOT(procReadyRead(const QByteArray&)));
  86
  87                 connect(this, SIGNAL(eof()), receiver, SLOT(procFinished()));
  88         }
  89         Domain* d = git->curContext();
  90         if (d)
  91                 connect(d, SIGNAL(cancelDomainProcesses()), this, SLOT(on_cancel()));
  92 }
  93
  94 void MyProcess::sendErrorMsg(bool notStarted, SCRef err) {
  95
  96         if (!errorReportingEnabled)
  97                 return;
  98
  99         QString errorDesc(readAllStandardError());
 100         errorDesc.prepend(err);
 101
 102         if (notStarted)
 103                 errorDesc = QString::fromLatin1("Unable to start the process!");
 104
 105         const QString cmd(arguments.join(" ")); // hide any QUOTE_CHAR or related stuff
 106         MainExecErrorEvent* e = new MainExecErrorEvent(cmd, errorDesc);
 107         QApplication::postEvent(guiObject, e);
 108 }
 109
 110 bool MyProcess::launchMe(SCRef runCmd, SCRef buf) {
 111
 112         arguments = splitArgList(runCmd);
 113         if (arguments.isEmpty())
 114                 return false;
 115
 116         setWorkingDirectory(workDir);
 117         if (!QGit::startProcess(this, arguments, buf, &isWinShell)) {
 118                 sendErrorMsg(true);
 119                 return false;
 120         }
 121         return true;
 122 }
 123
 124 void MyProcess::on_readyReadStandardOutput() {
 125
 126         if (canceling)
 127                 return;
 128
 129         if (receiver)
 130                 emit procDataReady(readAllStandardOutput());
 131
 132         else if (runOutput)
 133                 runOutput->append(readAllStandardOutput());
 134 }
 135
 136 void MyProcess::on_readyReadStandardError() {
 137
 138         if (canceling)
 139                 return;
 140
 141         if (receiver)
 142                 emit procDataReady(readAllStandardError()); // redirect to stdout
 143         else
 144                 dbs("ASSERT in myReadFromStderr: NULL receiver");
 145 }
 146
 147 void MyProcess::on_finished(int exitCode, QProcess::ExitStatus exitStatus) {
 148
 149         // Checking exingStatus is not reliable under Windows where if the
 150         // process was terminated with TerminateProcess() from another
 151         // application its value is still NormalExit
 152         //
 153         // Checking exit code for a failing command is unreliable too, as
 154         // exmple 'git status' returns 1 also without errors.
 155         //
 156         // On Windows exit code seems reliable in case of a command wrapped
 157         // in Window shell interpreter.
 158         //
 159         // So to detect a failing command we check also if stderr is not empty.
 160         QString errorDesc(readAllStandardError());
 161
 162         isErrorExit =   (exitStatus != QProcess::NormalExit)
 163                      || (exitCode != 0 && isWinShell)
 164                      || !errorDesc.isEmpty()
 165                      ||  canceling;
 166
 167         if (!canceling) { // no more noise after cancel
 168
 169                 if (receiver)
 170                         emit eof();
 171
 172                 if (isErrorExit)
 173                         sendErrorMsg(false, errorDesc);
 174         }
 175         busy = false;
 176         if (async)
 177                 deleteLater();
 178 }
 179
 180 void MyProcess::on_cancel() {
 181
 182         canceling = true;
 183
 184 #ifdef Q_OS_WIN32
 185         kill(); // uses TerminateProcess
 186 #else
 187         terminate(); // uses SIGTERM signal
 188 #endif
 189         waitForFinished();
 190 }
 191
 192 const QStringList MyProcess::splitArgList(SCRef cmd) {
 193 // return argument list handling quotes and double quotes
 194 // substring, as example from:
 195 // cmd some_arg "some thing" v='some value'
 196 // to (comma separated fields)
 197 // sl = <cmd,some_arg,some thing,v='some value'>
 198
 199         // early exit the common case
 200         if (!(   cmd.contains(QGit::QUOTE_CHAR)
 201               || cmd.contains("\"")
 202               || cmd.contains("\'")))
 203                 return cmd.split(' ', QString::SkipEmptyParts);
 204
 205         // we have some work to do...
 206         // first find a possible separator
 207         const QString sepList("#%&!?"); // separator candidates
 208         int i = 0;
 209         while (cmd.contains(sepList[i]) && i < sepList.length())
 210                 i++;
 211
 212         if (i == sepList.length()) {
 213                 dbs("ASSERT no unique separator found.");
 214                 return QStringList();
 215         }
 216         const QChar& sepChar(sepList[i]);
 217
 218         // remove all spaces
 219         QString newCmd(cmd);
 220         newCmd.replace(QChar(' '), sepChar);
 221
 222         // re-add spaces in quoted sections
 223         restoreSpaces(newCmd, sepChar);
 224
 225         // QUOTE_CHAR is used internally to delimit arguments
 226         // with quoted text wholly inside as
 227         // arg1 = <[patch] cool patch on "cool feature">
 228         // and should be removed before to feed QProcess
 229         newCmd.remove(QGit::QUOTE_CHAR);
 230
 231         // QProcess::setArguments doesn't want quote
 232         // delimited arguments, so remove trailing quotes
 233         QStringList sl(newCmd.split(sepChar, QString::SkipEmptyParts));
 234         QStringList::iterator it(sl.begin());
 235         for ( ; it != sl.end(); ++it) {
 236                 if (((*it).left(1) == "\"" && (*it).right(1) == "\"") ||
 237                    ((*it).left(1) == "\'" && (*it).right(1) == "\'"))
 238                         *it = (*it).mid(1, (*it).length() - 2);
 239         }
 240         return sl;
 241 }
 242
 243 void MyProcess::restoreSpaces(QString& newCmd, const QChar& sepChar) {
 244 // restore spaces inside quoted text, supports nested quote types
 245
 246         QChar quoteChar;
 247         bool replace = false;
 248         for (int i = 0; i < newCmd.length(); i++) {
 249
 250                 const QChar& c = newCmd[i];
 251
 252                 if (    !replace
 253                     && (c == QGit::QUOTE_CHAR[0] || c == '\"' || c == '\'')
 254                     && (newCmd.count(c) % 2 == 0)) {
 255
 256                                 replace = true;
 257                                 quoteChar = c;
 258                                 continue;
 259                 }
 260                 if (replace && (c == quoteChar)) {
 261                         replace = false;
 262                         continue;
 263                 }
 264                 if (replace && c == sepChar)
 265                         newCmd[i] = QChar(' ');
 266         }
 267 }