comparison src/plugincandidates.cpp @ 55:81ce3ba92b16

Try to forward stderr from the checker to the log callback

 {
     vector<string> candidates;
 
     for (string dirname: path) {
 
-        log("scanning directory " + dirname);
+        log("Scanning directory " + dirname);
 
         QDir dir(dirname.c_str(), PLUGIN_GLOB,
                  QDir::Name | QDir::IgnoreCase,
                  QDir::Files | QDir::Readable);
 

                        vector<string> pluginPath,
                        string descriptorSymbolName)
 {
     string helperVersion = getHelperCompatibilityVersion();
     if (helperVersion != CHECKER_COMPATIBILITY_VERSION) {
-        log("wrong plugin checker helper version found: expected v" +
+        log("Wrong plugin checker helper version found: expected v" +
             string(CHECKER_COMPATIBILITY_VERSION) + ", found v" +
             helperVersion);
         throw runtime_error("wrong version of plugin load helper found");
     }
     

             // Helper bailed out for some reason presumably associated
             // with the plugin following the last one it reported
             // on. Add a failure entry for that one and continue with
             // the following ones.
             string failed = *(remaining.rbegin() + shortfall - 1);
-            log("helper output ended before result for plugin " + failed);
+            log("Helper output ended before result for plugin " + failed);
             result.push_back("FAILURE|" + failed + "|Plugin load check failed or timed out");
             remaining = vector<string>
                 (remaining.rbegin(), remaining.rbegin() + shortfall - 1);
         }
         ++runcount;

     while (output.endsWith('\n') || output.endsWith('\r')) {
         output.chop(1);
     }
 
     string versionString = QString(output).toStdString();
-    log("read version string from helper: " + versionString);
+    log("Read version string from helper: " + versionString);
     return versionString;
 }
 
 vector<string>
 PluginCandidates::runHelper(vector<string> libraries, string descriptor)
 {
     vector<string> output;
 
-    log("running helper " + m_helper + " with following library list:");
+    log("Running helper " + m_helper + " with following library list:");
     for (auto &lib: libraries) log(lib);
 
     QProcess process;
     process.setReadChannel(QProcess::StandardOutput);
-    process.setProcessChannelMode(QProcess::ForwardedErrorChannel);
+
+    if (m_logCallback) {
+        log("Log callback is set: using separate-channels mode to gather stderr");
+        process.setProcessChannelMode(QProcess::SeparateChannels);
+    } else {
+        process.setProcessChannelMode(QProcess::ForwardedErrorChannel);
+    }
+    
     process.start(m_helper.c_str(), { descriptor.c_str() });
     
     if (!process.waitForStarted()) {
         QProcess::ProcessError err = process.error();
         if (err == QProcess::FailedToStart) {

         } else {
             std::cerr << "Helper process " << m_helper
                       << " failed on startup with error code "
                       << err << std::endl;
         }
+        logErrors(&process);
         throw runtime_error("plugin load helper failed to start");
     }
+
+    log("Helper " + m_helper + " started OK");
+    logErrors(&process);
     
     for (auto &lib: libraries) {
         process.write(lib.c_str(), lib.size());
         process.write("\n", 1);
     }

         if (linelen > 0) {
             output.push_back(buf);
             done = (output.size() == libraries.size());
         } else if (linelen < 0) {
             // error case
-            log("received error code while reading from helper");
+            log("Received error code while reading from helper");
             done = true;
         } else {
             // no error, but no line read (could just be between
             // lines, or could be eof)
             done = (process.state() == QProcess::NotRunning);
             if (!done) {
                 if (t.elapsed() > timeout) {
                     // this is purely an emergency measure
-                    log("timeout: helper took too long, killing it");
+                    log("Timeout: helper took too long, killing it");
                     process.kill();
                     done = true;
                 } else {
                     process.waitForReadyRead(200);
                 }
             }
         }
+        logErrors(&process);
     }
 
     if (process.state() != QProcess::NotRunning) {
         process.close();
         process.waitForFinished();
-    }
-
-    log("helper completed");
+        logErrors(&process);
+    }
+
+    log("Helper completed");
     
     return output;
+}
+
+void
+PluginCandidates::logErrors(QProcess *p)
+{
+    p->setReadChannel(QProcess::StandardError);
+
+    qint64 byteCount = p->bytesAvailable();
+    if (byteCount == 0) {
+        log("Helper emitted no stderr output");
+        p->setReadChannel(QProcess::StandardOutput);
+        return;
+    }
+
+    QByteArray buffer = p->read(byteCount);
+    while (buffer.endsWith('\n') || buffer.endsWith('\r')) {
+        buffer.chop(1);
+    }
+    std::string str(buffer.constData(), buffer.size());
+    log("Helper stderr output follows:\n" + str);
+    log("Helper stderr output ends");
+    
+    p->setReadChannel(QProcess::StandardOutput);
 }
 
 void
 PluginCandidates::recordResult(string tag, vector<string> result)
 {
     for (auto &r: result) {
 
         QString s(r.c_str());
         QStringList bits = s.split("|");
 
-        log(("read output line from helper: " + s.trimmed()).toStdString());
+        log(("Read output line from helper: " + s.trimmed()).toStdString());
         
         if (bits.size() < 2 || bits.size() > 3) {
-            log("invalid output line (wrong number of |-separated fields)");
+            log("Invalid output line (wrong number of |-separated fields)");
             continue;
         }
 
         string status = bits[0].toStdString();
         

             if (codeRE.exactMatch(messageAndCode)) {
                 QStringList caps(codeRE.capturedTexts());
                 if (caps.length() == 3) {
                     message = caps[1].toStdString();
                     code = PluginCheckCode(caps[2].toInt());
-                    log("split failure report into message and failure code "
+                    log("Split failure report into message and failure code "
                         + caps[2].toStdString());
                 } else {
-                    log("unable to split out failure code from report");
+                    log("Unable to split out failure code from report");
                 }
             } else {
-                log("failure message does not give a failure code");
+                log("Failure message does not give a failure code");
             }
 
             if (message == "") {
                 message = messageAndCode.toStdString();
             }
 
             m_failures[tag].push_back({ library, code, message });
 
         } else {
-            log("unexpected status \"" + status + "\" in output line");
-        }
-    }
-}
-
+            log("Unexpected status \"" + status + "\" in output line");
+        }
+    }
+}
+