| /*------------------------------------------------------------------------- | |
| * drawElements Quality Program Execution Server | |
| * --------------------------------------------- | |
| * | |
| * Copyright 2014 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| *//*! | |
| * \file | |
| * \brief TestProcess implementation for Win32. | |
| *//*--------------------------------------------------------------------*/ | |
| #include "xsWin32TestProcess.hpp" | |
| #include "deFilePath.hpp" | |
| #include "deString.h" | |
| #include "deMemory.h" | |
| #include "deClock.h" | |
| #include "deFile.h" | |
| #include <sstream> | |
| #include <string.h> | |
| using std::string; | |
| using std::vector; | |
| namespace xs | |
| { | |
| enum | |
| { | |
| MAX_OLD_LOGFILE_DELETE_ATTEMPTS = 20, //!< How many times execserver tries to delete old log file | |
| LOGFILE_DELETE_SLEEP_MS = 50 //!< Sleep time (in ms) between log file delete attempts | |
| }; | |
| namespace win32 | |
| { | |
| // Error | |
| static std::string formatErrMsg(DWORD error, const char *msg) | |
| { | |
| std::ostringstream str; | |
| LPSTR msgBuf; | |
| #if defined(UNICODE) | |
| #error Unicode not supported. | |
| #endif | |
| if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, | |
| error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&msgBuf, 0, DE_NULL) > 0) | |
| str << msg << ", error " << error << ": " << msgBuf; | |
| else | |
| str << msg << ", error " << error; | |
| return str.str(); | |
| } | |
| Error::Error(DWORD error, const char *msg) : std::runtime_error(formatErrMsg(error, msg)), m_error(error) | |
| { | |
| } | |
| // Event | |
| Event::Event(bool manualReset, bool initialState) : m_handle(0) | |
| { | |
| m_handle = CreateEvent(NULL, manualReset ? TRUE : FALSE, initialState ? TRUE : FALSE, NULL); | |
| if (!m_handle) | |
| throw Error(GetLastError(), "CreateEvent() failed"); | |
| } | |
| Event::~Event(void) | |
| { | |
| CloseHandle(m_handle); | |
| } | |
| void Event::setSignaled(void) | |
| { | |
| if (!SetEvent(m_handle)) | |
| throw Error(GetLastError(), "SetEvent() failed"); | |
| } | |
| void Event::reset(void) | |
| { | |
| if (!ResetEvent(m_handle)) | |
| throw Error(GetLastError(), "ResetEvent() failed"); | |
| } | |
| // CaseListWriter | |
| CaseListWriter::CaseListWriter(void) : m_dst(INVALID_HANDLE_VALUE), m_cancelEvent(true, false) | |
| { | |
| } | |
| CaseListWriter::~CaseListWriter(void) | |
| { | |
| } | |
| void CaseListWriter::start(const char *caseList, HANDLE dst) | |
| { | |
| DE_ASSERT(!isStarted()); | |
| m_dst = dst; | |
| int caseListSize = (int)strlen(caseList) + 1; | |
| m_caseList.resize(caseListSize); | |
| std::copy(caseList, caseList + caseListSize, m_caseList.begin()); | |
| de::Thread::start(); | |
| } | |
| void CaseListWriter::run(void) | |
| { | |
| try | |
| { | |
| Event ioEvent(true, false); // Manual reset, non-signaled state. | |
| HANDLE waitHandles[] = {ioEvent.getHandle(), m_cancelEvent.getHandle()}; | |
| OVERLAPPED overlapped; | |
| int curPos = 0; | |
| deMemset(&overlapped, 0, sizeof(overlapped)); | |
| overlapped.hEvent = ioEvent.getHandle(); | |
| while (curPos < (int)m_caseList.size()) | |
| { | |
| const int maxWriteSize = 4096; | |
| const int numToWrite = de::min(maxWriteSize, (int)m_caseList.size() - curPos); | |
| DWORD waitRes = 0; | |
| if (!WriteFile(m_dst, &m_caseList[curPos], (DWORD)numToWrite, NULL, &overlapped)) | |
| { | |
| DWORD err = GetLastError(); | |
| if (err != ERROR_IO_PENDING) | |
| throw Error(err, "WriteFile() failed"); | |
| } | |
| waitRes = WaitForMultipleObjects(DE_LENGTH_OF_ARRAY(waitHandles), &waitHandles[0], FALSE, INFINITE); | |
| if (waitRes == WAIT_OBJECT_0) | |
| { | |
| DWORD numBytesWritten = 0; | |
| // \note GetOverlappedResult() will fail with ERROR_IO_INCOMPLETE if IO event is not complete (should be). | |
| if (!GetOverlappedResult(m_dst, &overlapped, &numBytesWritten, FALSE)) | |
| throw Error(GetLastError(), "GetOverlappedResult() failed"); | |
| if (numBytesWritten == 0) | |
| throw Error(GetLastError(), "Writing to pipe failed (pipe closed?)"); | |
| curPos += (int)numBytesWritten; | |
| } | |
| else if (waitRes == WAIT_OBJECT_0 + 1) | |
| { | |
| // Cancel. | |
| if (!CancelIo(m_dst)) | |
| throw Error(GetLastError(), "CancelIo() failed"); | |
| break; | |
| } | |
| else | |
| throw Error(GetLastError(), "WaitForMultipleObjects() failed"); | |
| } | |
| } | |
| catch (const std::exception &e) | |
| { | |
| // \todo [2013-08-13 pyry] What to do about this? | |
| printf("win32::CaseListWriter::run(): %s\n", e.what()); | |
| } | |
| } | |
| void CaseListWriter::stop(void) | |
| { | |
| if (!isStarted()) | |
| return; // Nothing to do. | |
| m_cancelEvent.setSignaled(); | |
| // Join thread. | |
| join(); | |
| m_cancelEvent.reset(); | |
| m_dst = INVALID_HANDLE_VALUE; | |
| } | |
| // FileReader | |
| FileReader::FileReader(ThreadedByteBuffer *dst) | |
| : m_dstBuf(dst) | |
| , m_handle(INVALID_HANDLE_VALUE) | |
| , m_cancelEvent(false, false) | |
| { | |
| } | |
| FileReader::~FileReader(void) | |
| { | |
| } | |
| void FileReader::start(HANDLE file) | |
| { | |
| DE_ASSERT(!isStarted()); | |
| m_handle = file; | |
| de::Thread::start(); | |
| } | |
| void FileReader::run(void) | |
| { | |
| try | |
| { | |
| Event ioEvent(true, false); // Manual reset, not signaled state. | |
| HANDLE waitHandles[] = {ioEvent.getHandle(), m_cancelEvent.getHandle()}; | |
| OVERLAPPED overlapped; | |
| std::vector<uint8_t> tmpBuf(FILEREADER_TMP_BUFFER_SIZE); | |
| uint64_t offset = 0; // Overlapped IO requires manual offset keeping. | |
| deMemset(&overlapped, 0, sizeof(overlapped)); | |
| overlapped.hEvent = ioEvent.getHandle(); | |
| for (;;) | |
| { | |
| DWORD numBytesRead = 0; | |
| DWORD waitRes; | |
| overlapped.Offset = (DWORD)(offset & 0xffffffffu); | |
| overlapped.OffsetHigh = (DWORD)(offset >> 32); | |
| if (!ReadFile(m_handle, &tmpBuf[0], (DWORD)tmpBuf.size(), NULL, &overlapped)) | |
| { | |
| DWORD err = GetLastError(); | |
| if (err == ERROR_BROKEN_PIPE) | |
| break; | |
| else if (err == ERROR_HANDLE_EOF) | |
| { | |
| if (m_dstBuf->isCanceled()) | |
| break; | |
| deSleep(FILEREADER_IDLE_SLEEP); | |
| if (m_dstBuf->isCanceled()) | |
| break; | |
| else | |
| continue; | |
| } | |
| else if (err != ERROR_IO_PENDING) | |
| throw Error(err, "ReadFile() failed"); | |
| } | |
| waitRes = WaitForMultipleObjects(DE_LENGTH_OF_ARRAY(waitHandles), &waitHandles[0], FALSE, INFINITE); | |
| if (waitRes == WAIT_OBJECT_0) | |
| { | |
| // \note GetOverlappedResult() will fail with ERROR_IO_INCOMPLETE if IO event is not complete (should be). | |
| if (!GetOverlappedResult(m_handle, &overlapped, &numBytesRead, FALSE)) | |
| { | |
| DWORD err = GetLastError(); | |
| if (err == ERROR_HANDLE_EOF) | |
| { | |
| // End of file - for now. | |
| // \note Should check for end of buffer here, or otherwise may end up in infinite loop. | |
| if (m_dstBuf->isCanceled()) | |
| break; | |
| deSleep(FILEREADER_IDLE_SLEEP); | |
| if (m_dstBuf->isCanceled()) | |
| break; | |
| else | |
| continue; | |
| } | |
| else if (err == ERROR_BROKEN_PIPE) | |
| break; | |
| else | |
| throw Error(err, "GetOverlappedResult() failed"); | |
| } | |
| if (numBytesRead == 0) | |
| throw Error(GetLastError(), "Reading from file failed"); | |
| else | |
| offset += (uint64_t)numBytesRead; | |
| } | |
| else if (waitRes == WAIT_OBJECT_0 + 1) | |
| { | |
| // Cancel. | |
| if (!CancelIo(m_handle)) | |
| throw Error(GetLastError(), "CancelIo() failed"); | |
| break; | |
| } | |
| else | |
| throw Error(GetLastError(), "WaitForMultipleObjects() failed"); | |
| try | |
| { | |
| m_dstBuf->write((int)numBytesRead, &tmpBuf[0]); | |
| m_dstBuf->flush(); | |
| } | |
| catch (const ThreadedByteBuffer::CanceledException &) | |
| { | |
| // Canceled. | |
| break; | |
| } | |
| } | |
| } | |
| catch (const std::exception &e) | |
| { | |
| // \todo [2013-08-13 pyry] What to do? | |
| printf("win32::FileReader::run(): %s\n", e.what()); | |
| } | |
| } | |
| void FileReader::stop(void) | |
| { | |
| if (!isStarted()) | |
| return; // Nothing to do. | |
| m_cancelEvent.setSignaled(); | |
| // Join thread. | |
| join(); | |
| m_cancelEvent.reset(); | |
| m_handle = INVALID_HANDLE_VALUE; | |
| } | |
| // TestLogReader | |
| TestLogReader::TestLogReader(void) | |
| : m_logBuffer(LOG_BUFFER_BLOCK_SIZE, LOG_BUFFER_NUM_BLOCKS) | |
| , m_logFile(INVALID_HANDLE_VALUE) | |
| , m_reader(&m_logBuffer) | |
| { | |
| } | |
| TestLogReader::~TestLogReader(void) | |
| { | |
| if (m_logFile != INVALID_HANDLE_VALUE) | |
| CloseHandle(m_logFile); | |
| } | |
| void TestLogReader::start(const char *filename) | |
| { | |
| DE_ASSERT(m_logFile == INVALID_HANDLE_VALUE && !m_reader.isStarted()); | |
| m_logFile = CreateFile(filename, GENERIC_READ, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, DE_NULL, | |
| OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, DE_NULL); | |
| if (m_logFile == INVALID_HANDLE_VALUE) | |
| throw Error(GetLastError(), "Failed to open log file"); | |
| m_reader.start(m_logFile); | |
| } | |
| void TestLogReader::stop(void) | |
| { | |
| if (!m_reader.isStarted()) | |
| return; // Nothing to do. | |
| m_logBuffer.cancel(); | |
| m_reader.stop(); | |
| CloseHandle(m_logFile); | |
| m_logFile = INVALID_HANDLE_VALUE; | |
| m_logBuffer.clear(); | |
| } | |
| // Process | |
| Process::Process(void) | |
| : m_state(STATE_NOT_STARTED) | |
| , m_exitCode(0) | |
| , m_standardIn(INVALID_HANDLE_VALUE) | |
| , m_standardOut(INVALID_HANDLE_VALUE) | |
| , m_standardErr(INVALID_HANDLE_VALUE) | |
| { | |
| deMemset(&m_procInfo, 0, sizeof(m_procInfo)); | |
| } | |
| Process::~Process(void) | |
| { | |
| try | |
| { | |
| if (isRunning()) | |
| { | |
| kill(); | |
| waitForFinish(); | |
| } | |
| } | |
| catch (...) | |
| { | |
| } | |
| cleanupHandles(); | |
| } | |
| void Process::cleanupHandles(void) | |
| { | |
| DE_ASSERT(!isRunning()); | |
| if (m_standardErr != INVALID_HANDLE_VALUE) | |
| CloseHandle(m_standardErr); | |
| if (m_standardOut != INVALID_HANDLE_VALUE) | |
| CloseHandle(m_standardOut); | |
| if (m_standardIn != INVALID_HANDLE_VALUE) | |
| CloseHandle(m_standardIn); | |
| if (m_procInfo.hProcess) | |
| CloseHandle(m_procInfo.hProcess); | |
| if (m_procInfo.hThread) | |
| CloseHandle(m_procInfo.hThread); | |
| m_standardErr = INVALID_HANDLE_VALUE; | |
| m_standardOut = INVALID_HANDLE_VALUE; | |
| m_standardIn = INVALID_HANDLE_VALUE; | |
| deMemset(&m_procInfo, 0, sizeof(m_procInfo)); | |
| } | |
| __declspec(thread) static int t_pipeNdx = 0; | |
| static void createPipeWithOverlappedIO(HANDLE *readHandleOut, HANDLE *writeHandleOut, uint32_t readMode, | |
| uint32_t writeMode, SECURITY_ATTRIBUTES *securityAttr) | |
| { | |
| const int defaultBufSize = 4096; | |
| char pipeName[128]; | |
| HANDLE readHandle; | |
| HANDLE writeHandle; | |
| DE_ASSERT(((readMode | writeMode) & ~FILE_FLAG_OVERLAPPED) == 0); | |
| deSprintf(pipeName, sizeof(pipeName), "\\\\.\\Pipe\\dEQP-ExecServer-%08x-%08x-%08x", GetCurrentProcessId(), | |
| GetCurrentThreadId(), t_pipeNdx++); | |
| readHandle = CreateNamedPipe(pipeName, /* Pipe name. */ | |
| PIPE_ACCESS_INBOUND | readMode, /* Open mode. */ | |
| PIPE_TYPE_BYTE | PIPE_WAIT, /* Pipe flags. */ | |
| 1, /* Max number of instances. */ | |
| defaultBufSize, /* Output buffer size. */ | |
| defaultBufSize, /* Input buffer size. */ | |
| 0, /* Use default timeout. */ | |
| securityAttr); | |
| if (readHandle == INVALID_HANDLE_VALUE) | |
| throw Error(GetLastError(), "CreateNamedPipe() failed"); | |
| writeHandle = CreateFile(pipeName, GENERIC_WRITE, /* Access mode. */ | |
| 0, /* No sharing. */ | |
| securityAttr, OPEN_EXISTING, /* Assume existing object. */ | |
| FILE_ATTRIBUTE_NORMAL | writeMode, /* Open mode / flags. */ | |
| DE_NULL /* Template file. */); | |
| if (writeHandle == INVALID_HANDLE_VALUE) | |
| { | |
| DWORD openErr = GetLastError(); | |
| CloseHandle(readHandle); | |
| throw Error(openErr, "Failed to open created pipe, CreateFile() failed"); | |
| } | |
| *readHandleOut = readHandle; | |
| *writeHandleOut = writeHandle; | |
| } | |
| void Process::start(const char *commandLine, const char *workingDirectory) | |
| { | |
| // Pipes. | |
| HANDLE stdInRead = INVALID_HANDLE_VALUE; | |
| HANDLE stdInWrite = INVALID_HANDLE_VALUE; | |
| HANDLE stdOutRead = INVALID_HANDLE_VALUE; | |
| HANDLE stdOutWrite = INVALID_HANDLE_VALUE; | |
| HANDLE stdErrRead = INVALID_HANDLE_VALUE; | |
| HANDLE stdErrWrite = INVALID_HANDLE_VALUE; | |
| if (m_state == STATE_RUNNING) | |
| throw std::runtime_error("Process already running"); | |
| else if (m_state == STATE_FINISHED) | |
| { | |
| // Process finished, clean up old cruft. | |
| cleanupHandles(); | |
| m_state = STATE_NOT_STARTED; | |
| } | |
| // Create pipes | |
| try | |
| { | |
| SECURITY_ATTRIBUTES securityAttr; | |
| STARTUPINFO startInfo; | |
| deMemset(&startInfo, 0, sizeof(startInfo)); | |
| deMemset(&securityAttr, 0, sizeof(securityAttr)); | |
| // Security attributes for inheriting handle. | |
| securityAttr.nLength = sizeof(SECURITY_ATTRIBUTES); | |
| securityAttr.bInheritHandle = TRUE; | |
| securityAttr.lpSecurityDescriptor = DE_NULL; | |
| createPipeWithOverlappedIO(&stdInRead, &stdInWrite, 0, FILE_FLAG_OVERLAPPED, &securityAttr); | |
| createPipeWithOverlappedIO(&stdOutRead, &stdOutWrite, FILE_FLAG_OVERLAPPED, 0, &securityAttr); | |
| createPipeWithOverlappedIO(&stdErrRead, &stdErrWrite, FILE_FLAG_OVERLAPPED, 0, &securityAttr); | |
| if (!SetHandleInformation(stdInWrite, HANDLE_FLAG_INHERIT, 0) || | |
| !SetHandleInformation(stdOutRead, HANDLE_FLAG_INHERIT, 0) || | |
| !SetHandleInformation(stdErrRead, HANDLE_FLAG_INHERIT, 0)) | |
| throw Error(GetLastError(), "SetHandleInformation() failed"); | |
| // Startup info for process. | |
| startInfo.cb = sizeof(startInfo); | |
| startInfo.hStdError = stdErrWrite; | |
| startInfo.hStdOutput = stdOutWrite; | |
| startInfo.hStdInput = stdInRead; | |
| startInfo.dwFlags |= STARTF_USESTDHANDLES; | |
| if (!CreateProcess(DE_NULL, (LPTSTR)commandLine, DE_NULL, DE_NULL, TRUE /* inherit handles */, 0, DE_NULL, | |
| workingDirectory, &startInfo, &m_procInfo)) | |
| throw Error(GetLastError(), "CreateProcess() failed"); | |
| } | |
| catch (...) | |
| { | |
| if (stdInRead != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdInRead); | |
| if (stdInWrite != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdInWrite); | |
| if (stdOutRead != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdOutRead); | |
| if (stdOutWrite != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdOutWrite); | |
| if (stdErrRead != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdErrRead); | |
| if (stdErrWrite != INVALID_HANDLE_VALUE) | |
| CloseHandle(stdErrWrite); | |
| throw; | |
| } | |
| // Store handles to be kept. | |
| m_standardIn = stdInWrite; | |
| m_standardOut = stdOutRead; | |
| m_standardErr = stdErrRead; | |
| // Close other ends of handles. | |
| CloseHandle(stdErrWrite); | |
| CloseHandle(stdOutWrite); | |
| CloseHandle(stdInRead); | |
| m_state = STATE_RUNNING; | |
| } | |
| bool Process::isRunning(void) | |
| { | |
| if (m_state == STATE_RUNNING) | |
| { | |
| int exitCode; | |
| BOOL result = GetExitCodeProcess(m_procInfo.hProcess, (LPDWORD)&exitCode); | |
| if (result != TRUE) | |
| throw Error(GetLastError(), "GetExitCodeProcess() failed"); | |
| if (exitCode == STILL_ACTIVE) | |
| return true; | |
| else | |
| { | |
| // Done. | |
| m_exitCode = exitCode; | |
| m_state = STATE_FINISHED; | |
| return false; | |
| } | |
| } | |
| else | |
| return false; | |
| } | |
| void Process::waitForFinish(void) | |
| { | |
| if (m_state == STATE_RUNNING) | |
| { | |
| if (WaitForSingleObject(m_procInfo.hProcess, INFINITE) != WAIT_OBJECT_0) | |
| throw Error(GetLastError(), "Waiting for process failed, WaitForSingleObject() failed"); | |
| if (isRunning()) | |
| throw std::runtime_error("Process is still alive"); | |
| } | |
| else | |
| throw std::runtime_error("Process is not running"); | |
| } | |
| void Process::stopProcess(bool kill) | |
| { | |
| if (m_state == STATE_RUNNING) | |
| { | |
| if (!TerminateProcess(m_procInfo.hProcess, kill ? -1 : 0)) | |
| throw Error(GetLastError(), "TerminateProcess() failed"); | |
| } | |
| else | |
| throw std::runtime_error("Process is not running"); | |
| } | |
| void Process::terminate(void) | |
| { | |
| stopProcess(false); | |
| } | |
| void Process::kill(void) | |
| { | |
| stopProcess(true); | |
| } | |
| } // namespace win32 | |
| Win32TestProcess::Win32TestProcess(void) | |
| : m_process(DE_NULL) | |
| , m_processStartTime(0) | |
| , m_infoBuffer(INFO_BUFFER_BLOCK_SIZE, INFO_BUFFER_NUM_BLOCKS) | |
| , m_stdOutReader(&m_infoBuffer) | |
| , m_stdErrReader(&m_infoBuffer) | |
| { | |
| } | |
| Win32TestProcess::~Win32TestProcess(void) | |
| { | |
| delete m_process; | |
| } | |
| void Win32TestProcess::start(const char *name, const char *params, const char *workingDir, const char *caseList) | |
| { | |
| bool hasCaseList = strlen(caseList) > 0; | |
| XS_CHECK(!m_process); | |
| de::FilePath logFilePath = de::FilePath::join(workingDir, "TestResults.qpa"); | |
| m_logFileName = logFilePath.getPath(); | |
| // Remove old file if such exists. | |
| // \note Sometimes on Windows the test process dies slowly and may not release handle to log file | |
| // until a bit later. | |
| // \todo [2013-07-15 pyry] This should be solved by improving deProcess and killing all child processes as well. | |
| { | |
| int tryNdx = 0; | |
| while (tryNdx < MAX_OLD_LOGFILE_DELETE_ATTEMPTS && deFileExists(m_logFileName.c_str())) | |
| { | |
| if (deDeleteFile(m_logFileName.c_str())) | |
| break; | |
| deSleep(LOGFILE_DELETE_SLEEP_MS); | |
| tryNdx += 1; | |
| } | |
| if (deFileExists(m_logFileName.c_str())) | |
| throw TestProcessException(string("Failed to remove '") + m_logFileName + "'"); | |
| } | |
| // Construct command line. | |
| string cmdLine = | |
| de::FilePath(name).isAbsolutePath() ? name : de::FilePath::join(workingDir, name).normalize().getPath(); | |
| cmdLine += string(" --deqp-log-filename=") + logFilePath.getBaseName(); | |
| if (hasCaseList) | |
| cmdLine += " --deqp-stdin-caselist"; | |
| if (strlen(params) > 0) | |
| cmdLine += string(" ") + params; | |
| DE_ASSERT(!m_process); | |
| m_process = new win32::Process(); | |
| try | |
| { | |
| m_process->start(cmdLine.c_str(), strlen(workingDir) > 0 ? workingDir : DE_NULL); | |
| } | |
| catch (const std::exception &e) | |
| { | |
| delete m_process; | |
| m_process = DE_NULL; | |
| throw TestProcessException(e.what()); | |
| } | |
| m_processStartTime = deGetMicroseconds(); | |
| // Create stdout & stderr readers. | |
| m_stdOutReader.start(m_process->getStdOut()); | |
| m_stdErrReader.start(m_process->getStdErr()); | |
| // Start case list writer. | |
| if (hasCaseList) | |
| m_caseListWriter.start(caseList, m_process->getStdIn()); | |
| } | |
| void Win32TestProcess::terminate(void) | |
| { | |
| if (m_process) | |
| { | |
| try | |
| { | |
| m_process->kill(); | |
| } | |
| catch (const std::exception &e) | |
| { | |
| printf("Win32TestProcess::terminate(): Failed to kill process: %s\n", e.what()); | |
| } | |
| } | |
| } | |
| void Win32TestProcess::cleanup(void) | |
| { | |
| m_caseListWriter.stop(); | |
| // \note Buffers must be canceled before stopping readers. | |
| m_infoBuffer.cancel(); | |
| m_stdErrReader.stop(); | |
| m_stdOutReader.stop(); | |
| m_testLogReader.stop(); | |
| // Reset buffers. | |
| m_infoBuffer.clear(); | |
| if (m_process) | |
| { | |
| try | |
| { | |
| if (m_process->isRunning()) | |
| { | |
| m_process->kill(); | |
| m_process->waitForFinish(); | |
| } | |
| } | |
| catch (const std::exception &e) | |
| { | |
| printf("Win32TestProcess::cleanup(): Failed to kill process: %s\n", e.what()); | |
| } | |
| delete m_process; | |
| m_process = DE_NULL; | |
| } | |
| } | |
| int Win32TestProcess::readTestLog(uint8_t *dst, int numBytes) | |
| { | |
| if (!m_testLogReader.isRunning()) | |
| { | |
| if (deGetMicroseconds() - m_processStartTime > LOG_FILE_TIMEOUT * 1000) | |
| { | |
| // Timeout, kill process. | |
| terminate(); | |
| return 0; // \todo [2013-08-13 pyry] Throw exception? | |
| } | |
| if (!deFileExists(m_logFileName.c_str())) | |
| return 0; | |
| // Start reader. | |
| m_testLogReader.start(m_logFileName.c_str()); | |
| } | |
| DE_ASSERT(m_testLogReader.isRunning()); | |
| return m_testLogReader.read(dst, numBytes); | |
| } | |
| bool Win32TestProcess::isRunning(void) | |
| { | |
| if (m_process) | |
| return m_process->isRunning(); | |
| else | |
| return false; | |
| } | |
| int Win32TestProcess::getExitCode(void) const | |
| { | |
| if (m_process) | |
| return m_process->getExitCode(); | |
| else | |
| return -1; | |
| } | |
| } // namespace xs |