execserver/xsPosixTestProcess.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Execution Server
   3  * ---------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief TestProcess implementation for Unix-like systems.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "xsPosixTestProcess.hpp"
  25 #include "deFilePath.hpp"
  26 #include "deClock.h"
  27
  28 #include <string.h>
  29 #include <stdio.h>
  30
  31 using std::string;
  32 using std::vector;
  33
  34 namespace xs
  35 {
  36
  37 namespace posix
  38 {
  39
  40 CaseListWriter::CaseListWriter (void)
  41         : m_file        (DE_NULL)
  42         , m_run         (false)
  43 {
  44 }
  45
  46 CaseListWriter::~CaseListWriter (void)
  47 {
  48 }
  49
  50 void CaseListWriter::start (const char* caseList, deFile* dst)
  51 {
  52         DE_ASSERT(!isStarted());
  53         m_file  = dst;
  54         m_run   = true;
  55
  56         int caseListSize = (int)strlen(caseList)+1;
  57         m_caseList.resize(caseListSize);
  58         std::copy(caseList, caseList+caseListSize, m_caseList.begin());
  59
  60         // Set to non-blocking mode.
  61         if (!deFile_setFlags(m_file, DE_FILE_NONBLOCKING))
  62                 XS_FAIL("Failed to set non-blocking mode");
  63
  64         de::Thread::start();
  65 }
  66
  67 void CaseListWriter::run (void)
  68 {
  69         deInt64 pos = 0;
  70
  71         while (m_run && pos < (deInt64)m_caseList.size())
  72         {
  73                 deInt64                 numWritten      = 0;
  74                 deFileResult    result          = deFile_write(m_file, &m_caseList[0] + pos, m_caseList.size()-pos, &numWritten);
  75
  76                 if (result == DE_FILERESULT_SUCCESS)
  77                         pos += numWritten;
  78                 else if (result == DE_FILERESULT_WOULD_BLOCK)
  79                         deSleep(1); // Yield.
  80                 else
  81                         break; // Error.
  82         }
  83 }
  84
  85 void CaseListWriter::stop (void)
  86 {
  87         if (!isStarted())
  88                 return; // Nothing to do.
  89
  90         m_run = false;
  91
  92         // Join thread.
  93         join();
  94
  95         m_file = DE_NULL;
  96 }
  97
  98 PipeReader::PipeReader (ThreadedByteBuffer* dst)
  99         : m_file        (DE_NULL)
 100         , m_buf         (dst)
 101 {
 102 }
 103
 104 PipeReader::~PipeReader (void)
 105 {
 106 }
 107
 108 void PipeReader::start (deFile* file)
 109 {
 110         DE_ASSERT(!isStarted());
 111
 112         // Set to non-blocking mode.
 113         if (!deFile_setFlags(file, DE_FILE_NONBLOCKING))
 114                 XS_FAIL("Failed to set non-blocking mode");
 115
 116         m_file = file;
 117
 118         de::Thread::start();
 119 }
 120
 121 void PipeReader::run (void)
 122 {
 123         std::vector<deUint8>    tmpBuf          (FILEREADER_TMP_BUFFER_SIZE);
 124         deInt64                                 numRead         = 0;
 125
 126         while (!m_buf->isCanceled())
 127         {
 128                 deFileResult result = deFile_read(m_file, &tmpBuf[0], (deInt64)tmpBuf.size(), &numRead);
 129
 130                 if (result == DE_FILERESULT_SUCCESS)
 131                 {
 132                         // Write to buffer.
 133                         try
 134                         {
 135                                 m_buf->write((int)numRead, &tmpBuf[0]);
 136                                 m_buf->flush();
 137                         }
 138                         catch (const ThreadedByteBuffer::CanceledException&)
 139                         {
 140                                 // Canceled.
 141                                 break;
 142                         }
 143                 }
 144                 else if (result == DE_FILERESULT_END_OF_FILE ||
 145                                  result == DE_FILERESULT_WOULD_BLOCK)
 146                 {
 147                         // Wait for more data.
 148                         deSleep(FILEREADER_IDLE_SLEEP);
 149                 }
 150                 else
 151                         break; // Error.
 152         }
 153 }
 154
 155 void PipeReader::stop (void)
 156 {
 157         if (!isStarted())
 158                 return; // Nothing to do.
 159
 160         // Buffer must be in canceled state or otherwise stopping reader might block.
 161         DE_ASSERT(m_buf->isCanceled());
 162
 163         // Join thread.
 164         join();
 165
 166         m_file = DE_NULL;
 167 }
 168
 169 } // unix
 170
 171 PosixTestProcess::PosixTestProcess (void)
 172         : m_process                             (DE_NULL)
 173         , m_processStartTime    (0)
 174         , m_infoBuffer                  (INFO_BUFFER_BLOCK_SIZE, INFO_BUFFER_NUM_BLOCKS)
 175         , m_stdOutReader                (&m_infoBuffer)
 176         , m_stdErrReader                (&m_infoBuffer)
 177         , m_logReader                   (LOG_BUFFER_BLOCK_SIZE, LOG_BUFFER_NUM_BLOCKS)
 178 {
 179 }
 180
 181 PosixTestProcess::~PosixTestProcess (void)
 182 {
 183         delete m_process;
 184 }
 185
 186 void PosixTestProcess::start (const char* name, const char* params, const char* workingDir, const char* caseList)
 187 {
 188         bool hasCaseList = strlen(caseList) > 0;
 189
 190         XS_CHECK(!m_process);
 191
 192         de::FilePath logFilePath = de::FilePath::join(workingDir, "TestResults.qpa");
 193         m_logFileName = logFilePath.getPath();
 194
 195         // Remove old file if such exists.
 196         if (deFileExists(m_logFileName.c_str()))
 197         {
 198                 if (!deDeleteFile(m_logFileName.c_str()) || deFileExists(m_logFileName.c_str()))
 199                         throw TestProcessException(string("Failed to remove '") + m_logFileName + "'");
 200         }
 201
 202         // Construct command line.
 203         string cmdLine = de::FilePath(name).isAbsolutePath() ? name : de::FilePath::join(workingDir, name).getPath();
 204         cmdLine += string(" --deqp-log-filename=") + logFilePath.getBaseName();
 205
 206         if (hasCaseList)
 207                 cmdLine += " --deqp-stdin-caselist";
 208
 209         if (strlen(params) > 0)
 210                 cmdLine += string(" ") + params;
 211
 212         DE_ASSERT(!m_process);
 213         m_process = new de::Process();
 214
 215         try
 216         {
 217                 m_process->start(cmdLine.c_str(), strlen(workingDir) > 0 ? workingDir : DE_NULL);
 218         }
 219         catch (const de::ProcessError& e)
 220         {
 221                 delete m_process;
 222                 m_process = DE_NULL;
 223                 throw TestProcessException(e.what());
 224         }
 225
 226         m_processStartTime = deGetMicroseconds();
 227
 228         // Create stdout & stderr readers.
 229         if (m_process->getStdOut())
 230                 m_stdOutReader.start(m_process->getStdOut());
 231
 232         if (m_process->getStdErr())
 233                 m_stdErrReader.start(m_process->getStdErr());
 234
 235         // Start case list writer.
 236         if (hasCaseList)
 237         {
 238                 deFile* dst = m_process->getStdIn();
 239                 if (dst)
 240                         m_caseListWriter.start(caseList, dst);
 241                 else
 242                 {
 243                         cleanup();
 244                         throw TestProcessException("Failed to write case list");
 245                 }
 246         }
 247 }
 248
 249 void PosixTestProcess::terminate (void)
 250 {
 251         if (m_process)
 252         {
 253                 try
 254                 {
 255                         m_process->kill();
 256                 }
 257                 catch (const std::exception& e)
 258                 {
 259                         printf("PosixTestProcess::terminate(): Failed to kill process: %s\n", e.what());
 260                 }
 261         }
 262 }
 263
 264 void PosixTestProcess::cleanup (void)
 265 {
 266         m_caseListWriter.stop();
 267         m_logReader.stop();
 268
 269         // \note Info buffer must be canceled before stopping pipe readers.
 270         m_infoBuffer.cancel();
 271
 272         m_stdErrReader.stop();
 273         m_stdOutReader.stop();
 274
 275         // Reset info buffer.
 276         m_infoBuffer.clear();
 277
 278         if (m_process)
 279         {
 280                 try
 281                 {
 282                         if (m_process->isRunning())
 283                         {
 284                                 m_process->kill();
 285                                 m_process->waitForFinish();
 286                         }
 287                 }
 288                 catch (const de::ProcessError& e)
 289                 {
 290                         printf("PosixTestProcess::stop(): Failed to kill process: %s\n", e.what());
 291                 }
 292
 293                 delete m_process;
 294                 m_process = DE_NULL;
 295         }
 296 }
 297
 298 bool PosixTestProcess::isRunning (void)
 299 {
 300         if (m_process)
 301                 return m_process->isRunning();
 302         else
 303                 return false;
 304 }
 305
 306 int PosixTestProcess::getExitCode (void) const
 307 {
 308         if (m_process)
 309                 return m_process->getExitCode();
 310         else
 311                 return -1;
 312 }
 313
 314 int PosixTestProcess::readTestLog (deUint8* dst, int numBytes)
 315 {
 316         if (!m_logReader.isRunning())
 317         {
 318                 if (deGetMicroseconds() - m_processStartTime > LOG_FILE_TIMEOUT*1000)
 319                 {
 320                         // Timeout, kill process.
 321                         terminate();
 322                         return 0; // \todo [2013-08-13 pyry] Throw exception?
 323                 }
 324
 325                 if (!deFileExists(m_logFileName.c_str()))
 326                         return 0;
 327
 328                 // Start reader.
 329                 m_logReader.start(m_logFileName.c_str());
 330         }
 331
 332         DE_ASSERT(m_logReader.isRunning());
 333         return m_logReader.read(dst, numBytes);
 334 }
 335
 336 } // xs