judge/manager/program.cpp

   1 #include <sstream>
   2
   3 #include <stdarg.h>
   4
   5 #include <cassert>
   6
   7 #include "thread_util.h"
   8 #include "program.h"
   9
  10
  11 using namespace std;
  12
  13
  14 /**
  15  * Constructor
  16  * @param executablePath - path to the program that will be run
  17  *
  18  * Creates two pipes - one for each direction between the parent process and the AI program
  19  * Forks the process.
  20  *      The child process closes unused sides of the pipe, and then calls exec to replace itself with the AI program
  21  *      The parent process closes unused sides of the pipe, and sets up member variables - associates streams with the pipe fd's for convenience.
  22  */
  23 Program::Program(const char * executablePath) : input(NULL), output(NULL), pid(0)
  24 {
  25         //See if file exists and is executable...
  26         if (access(executablePath, X_OK) != 0)
  27         {
  28                 pid = -1;
  29                 return;
  30         }
  31
  32         int readPipe[2]; int writePipe[2];
  33         assert(pipe(readPipe) == 0);
  34         assert(pipe(writePipe) == 0);
  35
  36         pid = fork();
  37         if (pid == 0)
  38         {
  39                 close(readPipe[0]);  //close end that parent reads from
  40                 close(writePipe[1]); //close end that parent writes to
  41
  42                 //TODO: Fix possible bug here if the process is already a daemon
  43                 assert(writePipe[0] != 0 && readPipe[1] != 1);
  44                 dup2(writePipe[0],0); close(writePipe[0]); //pipe end child reads from goes to STDIN
  45                 dup2(readPipe[1], 1); close(readPipe[1]); //pipe end child writes to goes to STDOUT
  46
  47                 //TODO: Somehow force the exec'd process to be unbuffered
  48                 setbuf(stdin, NULL); //WARNING: These lines don't appear to have any affect
  49                 setbuf(stdout, NULL); //You should add them at the start of the wrapped program.
  50                                         //If your wrapped program is not written in C/C++, you will probably have a problem
  51
  52
  53                 if (access(executablePath, X_OK) == 0) //Check we STILL have permissions to start the file
  54                         execl(executablePath, executablePath, (char*)(NULL)); ///Replace process with desired executable
  55
  56                 fprintf(stderr, "Program::Program - Could not run program \"%s\"!\n", executablePath);
  57                 exit(EXIT_FAILURE); //We will probably have to terminate the whole program if this happens
  58         }
  59         else
  60         {
  61                 close(writePipe[0]); //close end that child writes to
  62                 close(readPipe[1]); //close end that child reads from
  63
  64                 input = fdopen(readPipe[0],"r"); output = fdopen(writePipe[1],"w");
  65                 setbuf(input, NULL);
  66                 setbuf(output, NULL);
  67         }
  68
  69 }
  70
  71 /**
  72  * Destructor
  73  * Writes EOF to the wrapped program and then closes all streams
  74  * Kills the wrapped program if it does not exit within 1 second.
  75  */
  76 Program::~Program()
  77 {
  78         if (Running()) //Check if the process created is still running...
  79         {
  80                 //fputc(EOF, output); //If it was, tell it to stop with EOF
  81
  82                 TimerThread timer(2); //Wait for 2 seconds
  83                 timer.Start();
  84                 while (!timer.Finished())
  85                 {
  86                         if (!Running())
  87                         {
  88                                 timer.Stop();
  89                                 break;
  90                         }
  91                 }
  92                 timer.Stop();
  93                 kill(pid, SIGKILL);
  94         }
  95         if (pid > 0)
  96         {
  97                 fclose(input);
  98                 fclose(output);
  99         }
 100
 101 }
 102
 103
 104
 105
 106
 107 /**
 108  * Sends a message to the wrapped AI program
 109  * WARNING: Always prints a new line after the message (so don't include a new line)
 110  *      This is because everything is always line buffered.
 111  * @returns true if the message was successfully sent; false if it was not (ie: the process was not running!)
 112  */
 113 bool Program::SendMessage(const char * print, ...)
 114 {
 115         if (!Running()) //Is the process running...
 116                 return false;
 117
 118         va_list ap;
 119         va_start(ap, print);
 120
 121         if (vfprintf(output, print, ap) < 0 || fprintf(output, "\n") < 0)
 122         {
 123                 va_end(ap);
 124                 return false;
 125         }
 126         va_end(ap);
 127
 128
 129
 130
 131         return true;
 132 }
 133
 134
 135 /**
 136  * Retrieves a message from the wrapped AI program, waiting a maximum amount of time
 137  * @param buffer - C++ string to store the resultant message in
 138  * @param timeout - Maximum amount of time to wait before failure. If timeout <= 0, then GetMessage will wait indefinately.
 139  * @returns true if the response was recieved within the specified time, false if it was not, or an EOF was recieved, or the process was not running.
 140  */
 141 bool Program::GetMessage(string & buffer, double timeout)
 142 {
 143         if (!Running() || timeout == 0)
 144                 return false;
 145
 146         assert(&buffer != NULL);
 147         GetterThread getterThread(input, buffer);
 148         assert(&(getterThread.buffer) != NULL);
 149
 150         TimerThread timerThread(timeout*1000000);
 151
 152         getterThread.Start();
 153         if (timeout > 0)
 154                 timerThread.Start();
 155
 156
 157         while (!getterThread.Finished())
 158         {
 159                 if (timeout > 0 && timerThread.Finished())
 160                 {
 161                         getterThread.Stop();
 162                         timerThread.Stop();
 163                         return false;
 164                 }
 165         }
 166
 167         getterThread.Stop();
 168         if (timeout > 0)
 169                 timerThread.Stop();
 170
 171
 172
 173         if (buffer.size() == 1 && buffer[0] == EOF)
 174                 return false;
 175         return true;
 176
 177
 178 }
 179
 180 /**
 181  * Returns true iff the process is running
 182  * @returns what I just said, fool
 183  */
 184 bool Program::Running() const
 185 {
 186         return (pid > 0 && kill(pid,0) == 0);
 187 }
 188
 189
 190
 191