Isis 3.0 Object Programmers' Reference

Home

---

Application.cpp

Go to the documentation of this file.

#include "IsisDebug.h"

#include <cstdio>
#include <sstream>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
extern int errno;
#include <QString>
#include <iostream>
#include <sstream>
#include <QCoreApplication>

#include "Application.h"
#include "UserInterface.h"
#include "Gui.h"
#include "Constants.h"
#include "Message.h"
#include "SessionLog.h"
#include "System.h"
#include "Preference.h"
#include "iException.h"
#include "CubeManager.h"

namespace Isis {
  Application *iApp = NULL;

  Application::Application (int argc, char *argv[]) {
    // Init socket communications
    p_socket = -1;
    p_childSocket = -1;
    p_socketFile = "";
    p_ui = NULL;

    // Save the application name
    p_appName = argv[0];

    // Get the starting wall clock time
    p_datetime = DateTime(&p_startTime);

    // Init
    p_startClock = 0;
    p_startDirectIO = 0;
    p_startPageFaults = 0;
    p_startProcessSwaps = 0;
    p_BatchlistPass = 0;

    // Get the starting cpu time, direct I/Os, page faults, and swaps
    p_startClock = clock();
    p_startDirectIO = DirectIO();
    p_startPageFaults = PageFaults();
    p_startProcessSwaps = ProcessSwaps();

    // Create user interface and log
    try {
      Isis::Filename f = std::string(argv[0]) + ".xml";

      // Create preferences
      Isis::Preference::Preferences(f.Name() == "unitTest.xml");

      if (!f.Exists()) {
        f = "$ISISROOT/bin/xml/" + f.Name();
        if (!f.Exists()) {
          std::string message = Isis::Message::FileOpen(f.Expanded());
          throw Isis::iException::Message(Isis::iException::Io,message,_FILEINFO_);
        }
      }
      std::string xmlfile = f.Expanded();

      p_ui = new Isis::UserInterface(xmlfile,argc,argv);
      if (!p_ui->IsInteractive()) {
        new QCoreApplication(argc,argv);
      }
      
    } catch (Isis::iException &e) {
      exit(e.Report());
    }

    iApp = this;
  }

  Application::~Application () {
    if (HasParent()) {
      SendParentData("DONE","");
      close(p_childSocket);
    }

    if (p_socket >= 0) {
      close(p_socket);
      remove(p_socketFile.c_str());
    }

    if(p_ui) {
      delete p_ui;
    }
  }

  int Application::Exec(void (*funct)()) {
    int status = 0;
    try {
      if (p_ui->IsInteractive()) {
        p_ui->TheGui()->Exec(funct);
      } else {
        if (p_ui->BatchListSize() > 0) {
          for (int i=0; i<p_ui->BatchListSize(); i++) {
            try {
              p_ui->SetBatchList(i);

              if (i != 0) {
                p_datetime = DateTime(&p_startTime);
                p_startClock = clock();
                p_startDirectIO = DirectIO();
                p_startPageFaults = PageFaults();
                p_startProcessSwaps = ProcessSwaps();
                SessionLog::TheLog(true);
              }

              funct();
              Application::FunctionCleanup();
              p_BatchlistPass++;
            } catch (Isis::iException &e) {
              p_ui->SetErrorList(i);
              status = Application::FunctionError(e);
              if (p_ui->AbortOnError()) {
                for (int j=(i+1); j<p_ui->BatchListSize(); j++) {
                  p_ui->SetErrorList(j);
                  p_BatchlistPass++;
                }
                break;
              }
            }
          }
        } else {
          p_ui->SaveHistory();
          // The gui checks everything but not the command line mode so
          // verify if necessary. Batchlist verifies on SetBatchList
          p_ui->VerifyAll();
          funct();
          Application::FunctionCleanup();
        }
      }
    } catch (Isis::iException &e) {
      status = Application::FunctionError(e);
    }

#if 0
    catch (std::exception &e) {
      std::string message = e.what ();
      Isis::iExceptionSystem i(message,_FILEINFO_);
      status = i.Report();
    } catch (...) {
      std::string message = "Unknown error expection";
      Isis::iExceptionSystem i(message,_FILEINFO_);
      status = i.Report();
    }
#endif

    return status;
  }

  PvlObject Application::History() {
    PvlObject history(p_ui->ProgramName());
    history += Isis::PvlKeyword("IsisVersion",Isis::version);
    history += Isis::PvlKeyword("ProgramVersion",p_ui->Version());
    QString path = QCoreApplication::applicationDirPath();
    history += Isis::PvlKeyword("ProgramPath", path);
    history += Isis::PvlKeyword("ExecutionDateTime",p_datetime);
    history += Isis::PvlKeyword("HostName",HostName());
    history += Isis::PvlKeyword("UserName",UserName());
    history += Isis::PvlKeyword("Description",p_ui->Brief());

    // Add the user parameters
    Isis::Pvl pvl;
    p_ui->CommandLine(pvl);
    history.AddGroup(pvl.FindGroup("UserParameters"));

    return history;
  }

  PvlGroup Application::Accounting () {
    // Grab the ending time to compute connect time
    time_t endTime = time(NULL);
    double seconds = difftime (endTime,p_startTime);
    int minutes = (int) (seconds / 60.0);
    seconds = seconds - minutes * 60.0;
    int hours = minutes / 60;
    minutes = minutes - hours * 60;
    char temp[80];
    sprintf(temp,"%02d:%02d:%04.1f",hours,minutes,seconds);
    std::string conTime = temp;

    // Grab the ending cpu time to compute total cpu time
    clock_t endClock = clock();
    seconds = (double(endClock) - (double)p_startClock) / CLOCKS_PER_SEC;
    minutes = (int) (seconds / 60.0);
    seconds = seconds - minutes * 60.0;
    hours = minutes / 60;
    minutes = minutes - hours * 60;
    sprintf(temp,"%02d:%02d:%04.1f",hours,minutes,seconds);
    std::string cpuTime = temp;

    // Add this information to the log
    PvlGroup acct("Accounting");
    acct += Isis::PvlKeyword("ConnectTime",conTime);
    acct += Isis::PvlKeyword("CpuTime",cpuTime);

    // Not sure if these are really valuable.  If deemed so then
    // uncomment and complete private methods (DirectIO, Pagefaults, and
    // ProcessSwaps).
    //int directIO = DirectIO();
    //int pageFaults = PageFaults();
    //int processSwaps = ProcessSwaps();
    //acct += Isis::PvlKeyword("DirectIo",directIO);
    //acct += Isis::PvlKeyword("PageFaults",pageFaults);
    //acct += Isis::PvlKeyword("ProcessSwaps",processSwaps);

    return acct;
  }

  int Application::DirectIO() {
    return 0 - p_startDirectIO;
  }

  int Application::PageFaults() {
    return 0 - p_startPageFaults;
  }

  int Application::ProcessSwaps() {
    return 0 - p_startProcessSwaps;
  }

  void Application::Log(PvlGroup &results) {
    // Add it to the log file
    static bool blankLine = false;
    SessionLog::TheLog().AddResults(results);

    // See if the log file will be written to the terminal/gui
    if (SessionLog::TheLog().TerminalOutput()) return;

    // See if we should write the info to our parents gui
    if (HasParent()) {
      std::ostringstream ostr;
      if (blankLine) ostr << std::endl;
      ostr << results << std::endl;
      std::string data = ostr.str();
      SendParentData (std::string("LOG"),data);
    }

    // Otherwise see if we need to write to our gui
    else if (iApp->GetUserInterface().IsInteractive()) {
      std::ostringstream ostr;
      if (blankLine) ostr << std::endl;
      ostr << results << std::endl;
      iApp->GetUserInterface().TheGui()->Log(ostr.str());
      iApp->GetUserInterface().TheGui()->ShowLog();
    }

    // Otherwise its command line mode
    else {
      if (blankLine) std::cout << std::endl;
      std::cout << results << std::endl;
    }
    blankLine = true;
  }

  void Application::GuiLog(Pvl &results) {
    // See if we should write the info to our parents gui
    if (HasParent()) {
      std::ostringstream ostr;
      ostr << results << std::endl;
      std::string data = ostr.str();
      SendParentData (std::string("LOG"),data);
    }

    // Otherwise see if we need to write to our gui
    else if (iApp->GetUserInterface().IsInteractive()) {
      std::ostringstream ostr;
      ostr << results << std::endl;
      iApp->GetUserInterface().TheGui()->Log(ostr.str());
      iApp->GetUserInterface().TheGui()->ShowLog();
    }
  }

  void Application::GuiLog(PvlGroup &results) {
    // See if we should write the info to our parents gui
    if (HasParent()) {
      std::ostringstream ostr;
      ostr << results << std::endl;
      std::string data = ostr.str();
      SendParentData (std::string("LOG"),data);
    }

    // Otherwise see if we need to write to our gui
    else if (iApp->GetUserInterface().IsInteractive()) {
      std::ostringstream ostr;
      ostr << results << std::endl;
      iApp->GetUserInterface().TheGui()->Log(ostr.str());
      iApp->GetUserInterface().TheGui()->ShowLog();
    }
  }

  void Application::GuiLog(std::string &results) {
    // See if we should write the info to our parents gui
    if (HasParent()) {
      SendParentData (std::string("LOG"),results);
    }

    // Otherwise see if we need to write to our gui
    else if (iApp->GetUserInterface().IsInteractive()) {
      iApp->GetUserInterface().TheGui()->Log(results);
      iApp->GetUserInterface().TheGui()->ShowLog();
    }
  }

  Isis::UserInterface &Application::GetUserInterface() {
    return *iApp->p_ui;
  }

  bool Application::HasParent () {
    if (iApp == NULL) return false;
    if (iApp->p_ui == NULL) return false;
    if (iApp->p_ui->ParentId() == 0) return false;
    return true;
  }

  void Application::SendParentErrors (Isis::PvlObject &errors) {
    for (int i=0; i<errors.Groups(); i++) {
      std::ostringstream ostr;
      ostr << errors.Group(i) << std::endl;
      std::string data = ostr.str();
      SendParentData (std::string("ERROR"),data);
    }
  }

  int Application::p_childSocket = -1;
  void Application::SendParentData(const std::string code, const std::string &message) {
    // See if we need to connect to the parent
    if (p_childSocket < 0) {
      std::string socketFile = "/tmp/isis_" + Isis::iString(iApp->GetUserInterface().ParentId());
      sockaddr_un socketName;
      socketName.sun_family = AF_UNIX;
      strcpy(socketName.sun_path,socketFile.c_str());
      p_childSocket = socket(PF_UNIX,SOCK_STREAM,0);
      if (p_childSocket == -1) {
        std::string msg = "Unable to create child-to-parent socket [" +
                          socketFile + "]";
        std::cout << msg << std::endl;
        throw Isis::iException::Message(Isis::iException::System,
                                        msg,_FILEINFO_);
      }

      errno = 0;
      int len = strlen(socketName.sun_path) + sizeof(socketName.sun_family);
      int status = connect(p_childSocket,(struct sockaddr *)&socketName,len);
      if (status == -1) {
        std::string msg = "Unable to connect to parent [" +
                          Isis::iString(iApp->GetUserInterface().ParentId()) + "] errno = " +
                          iString(errno);
        std::cout << msg << std::endl;
        throw Isis::iException::Message(Isis::iException::System,
                                        msg,_FILEINFO_);
      }
    }

    // Have connection so build data string and send it
    std::string data = code;
    data += char(27);
    if (message != "") {
      data += message;
      data += char(27);
    }

    if (send (p_childSocket,data.c_str(),data.size(),0) < 0) {
      std::string msg = "Unable to send to parent [" +
                        Isis::iString(iApp->GetUserInterface().ParentId()) + "]";
      std::cout << msg << std::endl;
      throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
    }
  }

  void Application::FunctionCleanup() {
    CubeManager::CleanUp();

    SessionLog::TheLog().Write();

    if (SessionLog::TheLog().TerminalOutput()) {
      if (HasParent()) {
        std::ostringstream ostr;
        ostr << SessionLog::TheLog() << std::endl;
        std::string data = ostr.str();
        SendParentData (std::string("LOG"),data);
      } else if (p_ui->IsInteractive()) {
        std::ostringstream ostr;
        ostr << SessionLog::TheLog() << std::endl;
        p_ui->TheGui()->Log(ostr.str());
        p_ui->TheGui()->ShowLog();
      } else {
        std::cout << SessionLog::TheLog() << std::endl;
      }
    }

    // If debugging flag on write debugging log
    if (p_ui->GetInfoFlag()) {
      std::string filename = p_ui->GetInfoFileName();
      Pvl log;
      iString app = (iString)QCoreApplication::applicationDirPath() + "/" + (iString)p_appName;
      if (p_BatchlistPass == 0) {
        std::stringstream ss ;
        ss << SessionLog::TheLog();
        ss.clear();
        ss >> log;
        PvlGroup uname = Isis::GetUnameInfo();
        PvlGroup env = Isis::GetEnviromentInfo();
        log.AddGroup(uname);
        log.AddGroup(env);     
      }

      // Write to file
      if (filename.compare("") != 0) {

        if (p_BatchlistPass == 0) {
          std::ofstream debugingLog (filename.c_str());
          if (!debugingLog.good()) {
            std::string msg = "Error opening debugging log file [" + filename + "]";
            throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
          }
          debugingLog << log << std::endl;
          debugingLog << "\n############### User Preferences ################\n" << std::endl;
          debugingLog << Preference::Preferences();
          debugingLog << "\n############## System Disk Space ################\n" << std::endl;
          debugingLog << SystemDiskSpace() << std::endl;
          debugingLog << "\n############ Executable Information #############\n" << std::endl;
          debugingLog << GetLibraryDependencies(app) << std::endl;
          debugingLog.close();
        } else {
          std::ofstream debugingLog (filename.c_str(),std::ios_base::app);
          debugingLog << SessionLog::TheLog() << std::endl;
          debugingLog.close();
        }        
      } else { // Write to std out
        if (p_BatchlistPass == 0) {
          std::cout << log << std::endl;
          std::cout << "\n############### User Preferences ################\n" << std::endl;
          std::cout << Preference::Preferences();
          std::cout << "\n############## System Disk Space ################\n" << std::endl;
          std::cout << SystemDiskSpace() << std::endl;
          std::cout << "\n############ Executable Information #############\n" << std::endl;
          std::cout << GetLibraryDependencies(app) << std::endl;
        } else {
          std::cout << SessionLog::TheLog() << std::endl;
        }
      }
    }


  }

  int Application::FunctionError(Isis::iException &e) {
    Pvl errors = e.PvlErrors();
    SessionLog::TheLog().AddError(errors);
    SessionLog::TheLog().Write();

    if (HasParent()) {
      SendParentErrors(errors);
    } else if (p_ui->IsInteractive()) {
      if (e.IsPvlFormat()) {
        std::ostringstream ostr;
        ostr << errors << std::endl;
        p_ui->TheGui()->LoadMessage(ostr.str());
      } else {
        p_ui->TheGui()->LoadMessage(e.Errors());
      }
    } else if (SessionLog::TheLog().TerminalOutput()) {
      std::cerr << SessionLog::TheLog() << std::endl;
    } else if (e.IsPvlFormat()) {
      std::cerr << errors << std::endl;
    } else {
      std::cerr << e.Errors() << std::endl;
    }

    // If debugging flag on write debugging log
    if (p_ui->GetInfoFlag()) {
      std::string filename = p_ui->GetInfoFileName();
      Pvl log;
      iString app = (iString)QCoreApplication::applicationDirPath() + "/" + (iString)p_appName;
      if (p_BatchlistPass == 0) {
        std::stringstream ss ;
        ss << SessionLog::TheLog();
        ss.clear();
        ss >> log;
        PvlGroup uname = Isis::GetUnameInfo();
        PvlGroup env = Isis::GetEnviromentInfo();
        log.AddGroup(uname);
        log.AddGroup(env);     
      }

      // Write to file
      if (filename.compare("") != 0) {
        if (p_BatchlistPass == 0) {
          std::ofstream debugingLog (filename.c_str());
          if (!debugingLog.good()) {
            std::string msg = "Error opening debugging log file [" + filename + "]";
            throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
          }
          debugingLog << log << std::endl;
          debugingLog << "\n############### User Preferences ################\n" << std::endl;
          debugingLog << Preference::Preferences();
          debugingLog << "\n############ System Disk Space #############\n" << std::endl;
          debugingLog << SystemDiskSpace() << std::endl;
          debugingLog << "\n############ Executable Information #############\n" << std::endl;
          debugingLog << GetLibraryDependencies(app) << std::endl;
          debugingLog.close();
        } else {
          std::ofstream debugingLog (filename.c_str(),std::ios_base::app);
          debugingLog << SessionLog::TheLog() << std::endl;
          debugingLog.close();
        }        
      } else { // Write to std out
        if (p_BatchlistPass == 0) {
          std::cout << log << std::endl;
          std::cout << "\n############### User Preferences ################\n" << std::endl;
          std::cout << Preference::Preferences();
          std::cout << "\n############ System Disk Space #############\n" << std::endl;
          std::cout << SystemDiskSpace() << std::endl;
          std::cout << "\n############ Executable Information #############\n" << std::endl;
          std::cout << GetLibraryDependencies(app) << std::endl;
        } else {
          std::cout << SessionLog::TheLog() << std::endl;
        }
      }
    }

    int errorType = (int)e.Type();
    e.Clear();
    return errorType;
  }

  void Application::GuiReportError(Isis::iException &e) {
    Pvl errors = e.PvlErrors();
    if (e.Type() == Isis::iException::Cancel) {
      e.Clear ();
      p_ui->TheGui()->ProgressText ("Stopped");
    }
    if (e.IsPvlFormat()) {
      std::ostringstream ostr;
      ostr << errors << std::endl;
      p_ui->TheGui()->LoadMessage(ostr.str());
    } else {
      p_ui->TheGui()->LoadMessage(e.Errors());
    }

    if (p_ui->TheGui()->ShowWarning ()) exit (0);
    p_ui->TheGui()->ProgressText ("Error");
    e.Clear();
  }

  QString Application::p_appName("Unknown");
  std::string Application::Name() {
    return p_appName.toStdString();
  }

  void Application::UpdateProgress(const std::string &text, bool print) {
    if (HasParent()) {
      std::string msg = p_ui->ProgramName() + ": " + text;
      SendParentData(std::string("PROGRESSTEXT"),msg);
    } else if (p_ui->IsInteractive()) {
      p_ui->TheGui()->ProgressText(text);
    } else if (print) {
      std::string msg = p_ui->ProgramName() + ": " + text;
      std::cout << msg << std::endl;
    }
  }

  void Application::UpdateProgress(int percent, bool print) {
    if (HasParent()) {
      std::string data = Isis::iString(percent);
      SendParentData(std::string("PROGRESS"),data);
    } else if (p_ui->IsInteractive()) {
      p_ui->TheGui()->Progress(percent);
    } else if (print) {
      if (percent < 100) {
        std::cout << percent << "% Processed\r" << std::flush;
      } else {
        std::cout << percent << "% Processed" << std::endl;
      }
    }
  }

  void Application::ProcessGuiEvents() {
    if (p_ui->IsInteractive()) {
      bool cancel = p_ui->TheGui()->ProcessEvents();
      if (cancel) {
        throw Isis::iException::Message(Isis::iException::Cancel,"",_FILEINFO_);
      }
    }
  }

  void Application::Exec(const std::string &program, const std::string &parameters) {
    // Setup the command line
    Isis::Filename bin(program);
    if (!bin.Exists()) {
      bin = "$ISISROOT/bin/" + program;
    }
    //Isis::Filename bin("$ISISROOT/bin/"+program);
    std::string command = bin.Expanded() + " " + parameters;

    // If we are interactive we must do an asychronous execute
    // so we can watch our socket
    if (p_ui->IsInteractive()) {
      p_pid = getpid();
      pid_t childPid;
      if ((childPid = fork()) == -1) {
        std::string msg = "Unable to execute command [" + command + "]";
        throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
      }

      if (childPid != 0) {
        EstablishConnections();
        ParentFork(command,program);
        ProcessGuiEvents();
      } else {
        ChildFork(command);
      }
    }
    // Handle command line programs invoked by GUI programs
    else if (HasParent()) {
      SendParentData("DISCONNECT","");
      close(p_childSocket);
      p_childSocket = -1;
      command += " -pid=" + Isis::iString((int)p_ui->ParentId());
      Isis::System(command);
      SendParentData("RECONNECT","");
    }
    // Otherwise just execute the command and wait for it to finish
    else {
      Isis::System(command);
    }
  }

  void Application::EstablishConnections() {
    if (p_socket != -1) return;

    // Create a socket
    if ((p_socket = socket(PF_UNIX,SOCK_STREAM,0)) == -1) {
      std::string msg = "Unable to create socket";
      throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
    }

    // Get the process id and create a unique filename
    p_socketFile = "/tmp/isis_" + Isis::iString((int)p_pid);

    // Bind the file to the socket
    p_socketName.sun_family = AF_UNIX;
    strcpy(p_socketName.sun_path,p_socketFile.c_str());
    int len = strlen(p_socketName.sun_path) + sizeof(p_socketName.sun_family);
    if (bind(p_socket,(struct sockaddr *)&p_socketName,len) == -1) {
      std::string msg = "Unable to bind to socket [" + p_socketFile + "]";
      throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
    }

    // Set up to listen to the socket
    if (listen(p_socket,5) == -1) {
      std::string msg = "Unable to listen to socket [" + p_socketFile + "]";
      throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
    }
  }

  void Application::ChildFork(const std::string &commandLine) {
    // The child fork doesn't have the socket
    p_socket = -1;

    // Append the pid as an argument
    std::string command = commandLine + " -pid=" + Isis::iString((int)p_pid);

    // Run the command
    int status = system (command.c_str());

    int childSocket = socket(PF_UNIX,SOCK_STREAM,0);
    if (childSocket == -1) {
      std::cout << "couldn't create socket to parent fork" << std::endl << std::flush;
      // What should we dooo???? How do we stop the parent?
      exit(255);
    }

    sockaddr_un socketName;
    socketName.sun_family = AF_UNIX;
    iString socketFile = "/tmp/isis_" + Isis::iString((int)p_pid);
    strcpy(socketName.sun_path,socketFile.c_str());

    int len = strlen(socketName.sun_path) + sizeof(socketName.sun_family);
    if (connect(childSocket,(struct sockaddr *)&socketName,len) == -1) {
      std::cout << "couldn't connect to parent fork" << std::endl << std::flush;
      // What should we dooo???? How do we stop the parent?
      exit(255);
    }

    if (status != 0) {
      char terminate[10] = "TERMINATE";
      terminate[9] = 27; // escape character
      if (send (childSocket,terminate,sizeof(terminate),0) < 0) {
        std::cout << "couldn't send terminate to parent fork" << std::endl << std::flush;
        // What should we dooo????  How do we stop the parent?
        exit(255);
      }
    } else {
      char success[8] = "SUCCESS";
      success[7] = 27; // escape character
      if (send (childSocket,success,sizeof(success),0) < 0) {
        std::cout << "couldn't send success to parent fork" << std::endl << std::flush;
        // What should we dooo???? How do we stop the parent?
        exit(255);
      }
    }

    close(childSocket);
    exit(0);
  }

  void Application::ParentFork(const std::string &command, const std::string &program) {
    // Try to accept a connection from the program our child fork executed.  If
    // the program we ran failed to start then we are waiting for the connection
    // in the child fork
    p_buffer = "";
    p_queue.clear();

    int childForkDone = false;
    while (!childForkDone) {
      int childSocket = -1;
      while (childSocket == -1) {
        errno = 0;
        socklen_t len = sizeof(p_socketName);
        childSocket = accept(p_socket, (struct sockaddr *)&p_socketName, &len);
        if (childSocket == -1) {
          if (errno != EINTR) {
            std::cout << "accept errno = " << errno << std::endl << std::flush;
            std::string msg = "Unable to accept socket connection [" +
                              p_socketFile + "] from child process";
            throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
          }
        }
      }

      // Looks like we are the parent so we must wait for input to come from
      // the child.
      bool done = false;
      while (!done) {
        WaitForCommand(childSocket);

        while (p_queue.size() > 0) {
          if (p_queue[0] == "DONE") {
            p_queue.erase(p_queue.begin());
            done = true;
          } else if (p_queue[0] == "DISCONNECT") {
            p_queue.erase(p_queue.begin());
            done = true;
          } else if (p_queue[0] == "RECONNECT") {
            p_queue.erase(p_queue.begin());
          } else if (p_queue[0] == "SUCCESS") {
            p_queue.erase(p_queue.begin());
            done = true;
            childForkDone = true;
          } else if (p_queue[0] == "TERMINATE") {
            // Should only happen if child fork could not fire off the process
            p_queue.erase(p_queue.begin());
            std::string msg = "Unable to execute command [" + command + "]";
            throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
          } else if (p_queue[0] == "ERROR") {
            p_queue.erase(p_queue.begin());
            while (p_queue.size() == 0) WaitForCommand(childSocket);
            std::stringstream str;
            str << p_queue[0];
            p_queue.erase(p_queue.begin());

            Isis::Pvl error;
            str >> error;

            for (int i=0; i<error.Groups(); i++) {
              Isis::PvlGroup &g = error.Group(i);
              std::string eclass = g["Class"];
              std::string emsg = g["Message"];
              int ecode = g["Code"];
              std::string efile = g["File"];
              int eline = g["Line"];

              Isis::iException::Message((Isis::iException::errType)ecode,
                                        emsg,(char *)efile.c_str(),eline);
            }
          } else if (p_queue[0] == "PROGRESSTEXT") {
            p_queue.erase(p_queue.begin());
            while (p_queue.size() == 0) WaitForCommand(childSocket);
            p_ui->TheGui()->ProgressText(p_queue[0]);
            p_ui->TheGui()->Progress(0);
            p_queue.erase(p_queue.begin());
          } else if (p_queue[0] == "PROGRESS") {
            p_queue.erase(p_queue.begin());
            while (p_queue.size() == 0) WaitForCommand(childSocket);
            p_ui->TheGui()->Progress(Isis::iString(p_queue[0]).ToInteger());
            p_queue.erase(p_queue.begin());
          } else if (p_queue[0] == "LOG") {
            p_queue.erase(p_queue.begin());
            while (p_queue.size() == 0) WaitForCommand(childSocket);

            std::stringstream str;
            str << p_queue[0];
            p_queue.erase(p_queue.begin());

            p_ui->TheGui()->Log(str.str());
          } else {
            std::string msg = "Unknown command [" + p_queue[0];
            msg += "] on socket [" + p_socketFile + "]";
            throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
          }
          ProcessGuiEvents();
        }
      }
      close(childSocket);
    }
  }

  void Application::WaitForCommand (int childSocket) {

    // Now we are ready to receive commands from our child (like in real
    // life) so receive the command
    int bytes;
    char buf[1024*1024];
    if ((bytes = recv(childSocket,&buf,1024*1024,0)) < 0) {
      std::string msg = "Unable to read from socket [" + p_socketFile + "]";
      throw Isis::iException::Message(Isis::iException::System,msg,_FILEINFO_);
    }

    // Push everything onto our string buffer
    for (int i=0; i<bytes; i++) p_buffer += buf[i];

    // Move esc delimited strings to our command queue
    std::string::size_type pos;
    while ((pos = p_buffer.find(27)) != std::string::npos) {
      p_queue.push_back(p_buffer.substr(0,pos));
      p_buffer.erase(0,pos+1);
    }
  }

  std::string Application::DateTime (time_t *curtime) {
    time_t startTime = time(NULL);
    if (curtime != 0) *curtime = startTime;
    struct tm *tmbuf = localtime(&startTime);
    char timestr[80];
    strftime(timestr,80,"%Y-%m-%dT%H:%M:%S",tmbuf);
    return(std::string) timestr;
  }

  std::string Application::UserName () {
    std::string user = "Unknown";
    char *userPtr = getenv("USER");
    if (userPtr != NULL) user = userPtr;
    return user;
  }

  std::string Application::HostName () {
    std::string host = "Unknown";
    char *hostPtr = getenv("HOST");
    if (hostPtr == NULL) hostPtr = getenv ("HOSTNAME");
    if (hostPtr != NULL) host = hostPtr;
    return host;
  }

}  //end namespace isis