comparison vamp-client/ProcessQtTransport.h @ 134:3dcf0394971d

Debug output improvements, and make the checker actually attempt to call the descriptor function for known plugin types

  * support switching threads.
  */
 class ProcessQtTransport : public SynchronousTransport
 {
 public:
-    ProcessQtTransport(std::string processName, std::string formatArg) :
+    ProcessQtTransport(std::string processName,
+                       std::string formatArg,
+                       LogCallback *logger) : // logger may be nullptr for cerr
+        m_logger(logger),
         m_completenessChecker(0),
         m_crashed(false) {
 
         m_process = new QProcess();
         m_process->setReadChannel(QProcess::StandardOutput);

         
         if (!m_process->waitForStarted()) {
             if (m_process->state() == QProcess::NotRunning) {
                 QProcess::ProcessError err = m_process->error();
                 if (err == QProcess::FailedToStart) {
-                    std::cerr << "Unable to start server process "
-                              << processName << std::endl;
+                    log("Unable to start server process " + processName);
                 } else if (err == QProcess::Crashed) {
-                    std::cerr << "Server process " << processName
-                              << " crashed on startup" << std::endl;
+                    log("Server process " + processName + " crashed on startup");
                 } else {
-                    std::cerr << "Server process " << processName
-                              << " failed on startup with error code "
-                              << err << std::endl;
+                    QString e = QString("%1").arg(err);
+                    log("Server process " + processName +
+                        " failed on startup with error code " + e.toStdString());
                 }
                 delete m_process;
                 m_process = nullptr;
             }
+        }
+
+        if (m_process) {
+            log("Server process " + processName + " started OK");
         }
     }
 
     ~ProcessQtTransport() {
         if (m_process) {
             if (m_process->state() != QProcess::NotRunning) {
                 m_process->closeWriteChannel();
                 m_process->waitForFinished(200);
                 m_process->close();
                 m_process->waitForFinished();
-#ifdef DEBUG_TRANSPORT
-                std::cerr << "server exited" << std::endl;
-#endif
+                log("Server process exited normally");
             }
             delete m_process;
         }
     }
 

     isOK() const override {
         return (m_process != nullptr) && !m_crashed;
     }
     
     std::vector<char>
-    call(const char *ptr, size_t size, bool slow) override {
+    call(const char *ptr, size_t size, std::string type, bool slow) override {
 
         QMutexLocker locker(&m_mutex);
         
         if (!m_completenessChecker) {
+            log("call: No completeness checker set on transport");
             throw std::logic_error("No completeness checker set on transport");
         }
         if (!isOK()) {
+            log("call: Transport is not OK");
             throw std::logic_error("Transport is not OK");
         }
         
 #ifdef DEBUG_TRANSPORT
         std::cerr << "writing " << size << " bytes to server" << std::endl;

                 if (m_process->state() == QProcess::NotRunning &&
                     // don't give up until we've read all that's been buffered!
                     !m_process->bytesAvailable()) {
                     QProcess::ProcessError err = m_process->error();
                     if (err == QProcess::Crashed) {
-                        std::cerr << "Server crashed during request" << std::endl;
+                        log("Server crashed during " + type + " request");
                     } else {
-                        std::cerr << "Server failed during request with error code "
-                                  << err << std::endl;
+                        QString e = QString("%1").arg(err);
+                        log("Server failed during " + type
+                            + " request with error code " + e.toStdString());
                     }
                     m_crashed = true;
                     throw ServerCrashed();
                 }
             } else {

 
         return buffer;
     }
     
 private:
+    LogCallback *m_logger;
     MessageCompletenessChecker *m_completenessChecker; //!!! I don't own this (currently)
     QProcess *m_process; // I own this
     QMutex m_mutex;
     bool m_crashed;
+
+    void log(std::string message) const {
+        if (m_logger) m_logger->log(message);
+        else std::cerr << message << std::endl;
+    }
 };
 
 }
 }