ProgramLauncher.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "ProgramLauncher.h"
 
#include <iostream>
#include <sstream>
#include <sys/wait.h>
 
#include <QLocalServer>
#include <QLocalSocket>
#include <QProcess>
 
#include "Application.h"
#include "FileName.h"
#include "IException.h"
#include "IString.h"
#include "Preference.h"
 
using namespace std;
namespace Isis {
  void ProgramLauncher::RunIsisProgram(QString programName,
                                       QString parameters) {
    FileName program(programName);
    FileName isisExecutableFileName("$ISISROOT/bin/" + program.name());
    bool isIsisProgram = false;
 
    if(isisExecutableFileName.fileExists()) {
      isIsisProgram = true;
      program = isisExecutableFileName;
    }
 
    PvlGroup &dataDir = Preference::Preferences().findGroup("DataDirectory");
    QString tempDir = dataDir["Temporary"];
 
    QString command = program.expanded() + " " + parameters +
        " -pid=" + toString(getpid());
    QStringList split = QProcess::splitCommand(command);
    QString app = split.takeFirst();
    QStringList paramList = split;
 
    if(!isIsisProgram) {
      QString msg = "Program [" + programName + "] does not appear to be a "
          "valid Isis program";
      throw IException(IException::Unknown, msg, _FILEINFO_);
    }
 
    QString serverName = "isis_" + Application::UserName() +
        "_" + toString(getpid());
 
    QLocalServer server;
    server.listen(serverName);
 
    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
    env.insert("TEMPORARY", tempDir);
 
    QProcess childProcess;
    childProcess.setProcessEnvironment(env);
    childProcess.setProcessChannelMode(QProcess::ForwardedChannels);
    childProcess.start(app, paramList);
    childProcess.waitForStarted();
 
    bool connected = false;
 
    while(!connected && childProcess.state() != QProcess::NotRunning) {
      // Give time for the process to connect to us or for it to finish
      // wait 30s for the new connection....
      connected = server.waitForNewConnection(30000);
      childProcess.waitForFinished(100);
    }
 
    if(!connected) {
      QString msg = "Isis child process failed to communicate with parent";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
 
    QLocalSocket *childSocket = server.nextPendingConnection();
    IException errors;
 
    // Don't return until we're done running this program
    while(childSocket->state() != QLocalSocket::UnconnectedState) {
      bool insideCode = true;
      bool messageDone = false;
 
      QString code;
      QString message;
      QByteArray lineData;
 
      if(childSocket->waitForReadyRead(1000)) {
        lineData = childSocket->read(childSocket->bytesAvailable());
 
        for(int i = 0; i < lineData.size(); i++) {
          if(insideCode) {
            if(lineData[i] != (char)27) {
              code += lineData[i];
            }
            else {
              insideCode = false;
            }
          }
          else {
            if(lineData[i] != (char)27) {
              message += lineData[i];
            }
            else {
              messageDone = true;
              insideCode = true;
              i ++; // skip \n that should always exist here
            }
          }
 
          if(messageDone) {
            errors.append(
              ProcessIsisMessageFromChild(code, message));
            code = "";
            message = "";
            messageDone = false;
          }
        }
      }
    }
 
    childProcess.waitForFinished();
 
    if(childProcess.exitCode() != 0) {
      QString msg = "Running Isis program [" + programName + "] failed with "
                    "return status [" + toString(childProcess.exitCode()) + "]";
      throw IException(errors, IException::Unknown, msg, _FILEINFO_);
    }
  }
 

  IException
      ProgramLauncher::ProcessIsisMessageFromChild(QString code, QString msg) {
    IException errors;
 
    if(code == "PROGRESSTEXT" && iApp) {
      iApp->UpdateProgress(msg, true);
    }
    else if(code == "PROGRESS" && iApp) {
      iApp->UpdateProgress(toInt(msg), true);
    }
    else if(code == "LOG" && iApp) {
      stringstream msgStream;
      msgStream << msg;
      Pvl logPvl;
      msgStream >> logPvl;
 
      if(logPvl.groups() == 1 &&
         logPvl.keywords() == 0 &&
         logPvl.objects() == 0) {
        iApp->Log(logPvl.group(0));
      }
    }
    else if(code == "GUILOG" && iApp) {
      iApp->GuiLog(msg);
    }
    else if(code == "ERROR") {
      stringstream msgStream;
      msgStream << msg;
      Pvl errorPvl;
      msgStream >> errorPvl;
 
      for(int i = 0; i < errorPvl.groups(); i++) {
        PvlGroup &g = errorPvl.group(i);
        QString emsg = g["Message"];
        int ecode = g["Code"];
        QString efile = g["File"];
        int eline = g["Line"];
 
        errors.append(
          IException((IException::ErrorType)ecode, emsg, efile.toLatin1().data(), eline));
      }
    }
 
    return errors;
  }
 

  void ProgramLauncher::RunSystemCommand(QString fullCommand) {
    int status = system(fullCommand.toLatin1().data());
 
    if(status != 0) {
      QString msg = "Executing command [" + fullCommand +
                    "] failed with return status [" + toString(status) + "]";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }
  }
}  //end namespace isis