ReceiverControl.h

Go to the documentation of this file.

// $Id: ReceiverControl.h,v 1.1.1.1 2009/07/06 23:57:23 eml Exp $

#ifndef GCP_MEDIATOR_RECEIVERCONTROL_H
#define GCP_MEDIATOR_RECEIVERCONTROL_H

#include <iostream>
#include <fstream>
#include <list>


#include "gcp/util/common/GenericTask.h"

#include "gcp/mediator/specific/ReceiverControlMsg.h"

namespace gcp {

  namespace util {
    class CoProc;
    class Port;
  }

  namespace mediator {

    class Control;
    
    class ReceiverControl : 
      public gcp::util::GenericTask<ReceiverControlMsg> {
      
    public:

      
      struct Script {

    enum Status {
      NONE,
      FAILED,
      OK
    };

    enum State {
      DONE,
      START,
      BODY,
      END,
    };

    enum Type {
      ERROR,
      MESSAGE,
      STATUS,
    };

    // The process associated with this script

    gcp::util::CoProc* proc_;

    // A file descriptor associated with the output file for this
    // script

    std::ofstream outFile_;

    gcp::util::Port* stdOut_;
    gcp::util::Port* stdErr_;

    // Variables for handling messages received over the stderr
    // pipe

    unsigned tagCount_;

    std::ostringstream startTag_;
    std::ostringstream message_;
    std::ostringstream endTag_;

    State messageState_;
    Type messageType_;

    // The seq id number associated with this script 

    unsigned seq_;

    // A return status from this script

    Status status_;

    bool stdOutWasClosed_;
    bool stdErrWasClosed_;

    std::string script_;

    //------------------------------------------------------------
    // Methods
    //------------------------------------------------------------

    // Constructor will be called with the command name to execute

    Script(std::string script, unsigned seq, std::string dir);

    ~Script();

    // Methods to return the stdout/stderr fds for this process

    int stdInFd();
    int stdOutFd();
    int stdErrFd();

    void open(std::string fileName);
    void close();
    
    // Copy data from the stdout pipe of the process to the output
    // file

    unsigned copyFromStdoutToFile();

    // Read the next string from stderr

    unsigned readFromStdErr();

      // Process a message received on stderr

    void processMessage();

    // Set the message type from the start tag that was read

    void setMessageType();

      };

      ReceiverControl(Control* parent);

      virtual ~ReceiverControl();

      // Forward a script message to the receiver control task.

      void sendScript(std::string script, unsigned seq);

      void run() {
    gcp::util::GenericTask<ReceiverControlMsg>::run();
      }

    private:

      friend class Control;

      Control* parent_;

      // The output directory

      std::string outputDir_;

      std::list<Script*> scripts_;

      // The list of scripts that finished on the last loop of select()

      std::list<Script*> finishedScripts_;

      // A logfile object for managing output file names

      gcp::util::LogFile logFile_;
      
      void serviceMsgQ();
      
      void processMsg(ReceiverControlMsg* taskMsg);

      // Register receipt of a command to execute a new script

      void installNewScript(char* script, unsigned seq);
      
      // Respond to data on the stdout pipe for this script

      void processStdOut(Script* script);

      // Respond to data on the stderr pipe for this script

      void processStdErr(Script* script);

      // Respond to data on the stdout pipe for this script

      void registerStdOutClosed(Script* script);

      // Respond to data on the stdout pipe for this script
      
      void registerStdErrClosed(Script* script);

      // Respond to data on the stdout pipe for this script

      void checkCompletionStatus(Script* script);

      // Register an error installing a new script

      void registerError(std::string message, unsigned seq);

      void removeFinishedScriptsFromList();

      // Send a script completion message to the control program

      void sendScriptCompletedMsg(unsigned seq);

    }; // End class ReceiverControl

  } // End namespace mediator
} // End namespace gcp



#endif // End #ifndef GCP_MEDIATOR_RECEIVERCONTROL_H