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 Win32. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "xsWin32TestProcess.hpp" 25 #include "deFilePath.hpp" 26 #include "deString.h" 27 #include "deMemory.h" 28 #include "deClock.h" 29 #include "deFile.h" 30 31 #include <sstream> 32 #include <string.h> 33 34 using std::string; 35 using std::vector; 36 37 namespace xs 38 { 39 40 enum 41 { 42 MAX_OLD_LOGFILE_DELETE_ATTEMPTS = 20, //!< How many times execserver tries to delete old log file 43 LOGFILE_DELETE_SLEEP_MS = 50 //!< Sleep time (in ms) between log file delete attempts 44 }; 45 46 namespace win32 47 { 48 49 // Error 50 51 static std::string formatErrMsg (DWORD error, const char* msg) 52 { 53 std::ostringstream str; 54 LPSTR msgBuf; 55 56 #if defined(UNICODE) 57 # error Unicode not supported. 58 #endif 59 60 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 61 NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&msgBuf, 0, DE_NULL) > 0) 62 str << msg << ", error " << error << ": " << msgBuf; 63 else 64 str << msg << ", error " << error; 65 66 return str.str(); 67 } 68 69 Error::Error (DWORD error, const char* msg) 70 : std::runtime_error(formatErrMsg(error, msg)) 71 , m_error (error) 72 { 73 } 74 75 // Event 76 77 Event::Event (bool manualReset, bool initialState) 78 : m_handle(0) 79 { 80 m_handle = CreateEvent(NULL, manualReset ? TRUE : FALSE, initialState ? TRUE : FALSE, NULL); 81 if (!m_handle) 82 throw Error(GetLastError(), "CreateEvent() failed"); 83 } 84 85 Event::~Event (void) 86 { 87 CloseHandle(m_handle); 88 } 89 90 void Event::setSignaled (void) 91 { 92 if (!SetEvent(m_handle)) 93 throw Error(GetLastError(), "SetEvent() failed"); 94 } 95 96 void Event::reset (void) 97 { 98 if (!ResetEvent(m_handle)) 99 throw Error(GetLastError(), "ResetEvent() failed"); 100 } 101 102 // CaseListWriter 103 104 CaseListWriter::CaseListWriter (void) 105 : m_dst (INVALID_HANDLE_VALUE) 106 , m_cancelEvent (true, false) 107 { 108 } 109 110 CaseListWriter::~CaseListWriter (void) 111 { 112 } 113 114 void CaseListWriter::start (const char* caseList, HANDLE dst) 115 { 116 DE_ASSERT(!isStarted()); 117 118 m_dst = dst; 119 120 int caseListSize = (int)strlen(caseList)+1; 121 m_caseList.resize(caseListSize); 122 std::copy(caseList, caseList+caseListSize, m_caseList.begin()); 123 124 de::Thread::start(); 125 } 126 127 void CaseListWriter::run (void) 128 { 129 try 130 { 131 Event ioEvent (true, false); // Manual reset, non-signaled state. 132 HANDLE waitHandles[] = { ioEvent.getHandle(), m_cancelEvent.getHandle() }; 133 OVERLAPPED overlapped; 134 int curPos = 0; 135 136 deMemset(&overlapped, 0, sizeof(overlapped)); 137 overlapped.hEvent = ioEvent.getHandle(); 138 139 while (curPos < (int)m_caseList.size()) 140 { 141 const int maxWriteSize = 4096; 142 const int numToWrite = de::min(maxWriteSize, (int)m_caseList.size() - curPos); 143 DWORD waitRes = 0; 144 145 if (!WriteFile(m_dst, &m_caseList[curPos], (DWORD)numToWrite, NULL, &overlapped)) 146 { 147 DWORD err = GetLastError(); 148 if (err != ERROR_IO_PENDING) 149 throw Error(err, "WriteFile() failed"); 150 } 151 152 waitRes = WaitForMultipleObjects(DE_LENGTH_OF_ARRAY(waitHandles), &waitHandles[0], FALSE, INFINITE); 153 154 if (waitRes == WAIT_OBJECT_0) 155 { 156 DWORD numBytesWritten = 0; 157 158 // \note GetOverlappedResult() will fail with ERROR_IO_INCOMPLETE if IO event is not complete (should be). 159 if (!GetOverlappedResult(m_dst, &overlapped, &numBytesWritten, FALSE)) 160 throw Error(GetLastError(), "GetOverlappedResult() failed"); 161 162 if (numBytesWritten == 0) 163 throw Error(GetLastError(), "Writing to pipe failed (pipe closed?)"); 164 165 curPos += (int)numBytesWritten; 166 } 167 else if (waitRes == WAIT_OBJECT_0 + 1) 168 { 169 // Cancel. 170 if (!CancelIo(m_dst)) 171 throw Error(GetLastError(), "CancelIo() failed"); 172 break; 173 } 174 else 175 throw Error(GetLastError(), "WaitForMultipleObjects() failed"); 176 } 177 } 178 catch (const std::exception& e) 179 { 180 // \todo [2013-08-13 pyry] What to do about this? 181 printf("win32::CaseListWriter::run(): %s\n", e.what()); 182 } 183 } 184 185 void CaseListWriter::stop (void) 186 { 187 if (!isStarted()) 188 return; // Nothing to do. 189 190 m_cancelEvent.setSignaled(); 191 192 // Join thread. 193 join(); 194 195 m_cancelEvent.reset(); 196 197 m_dst = INVALID_HANDLE_VALUE; 198 } 199 200 // FileReader 201 202 FileReader::FileReader (ThreadedByteBuffer* dst) 203 : m_dstBuf (dst) 204 , m_handle (INVALID_HANDLE_VALUE) 205 , m_cancelEvent (false, false) 206 { 207 } 208 209 FileReader::~FileReader (void) 210 { 211 } 212 213 void FileReader::start (HANDLE file) 214 { 215 DE_ASSERT(!isStarted()); 216 217 m_handle = file; 218 219 de::Thread::start(); 220 } 221 222 void FileReader::run (void) 223 { 224 try 225 { 226 Event ioEvent (true, false); // Manual reset, not signaled state. 227 HANDLE waitHandles[] = { ioEvent.getHandle(), m_cancelEvent.getHandle() }; 228 OVERLAPPED overlapped; 229 std::vector<deUint8> tmpBuf (FILEREADER_TMP_BUFFER_SIZE); 230 deUint64 offset = 0; // Overlapped IO requires manual offset keeping. 231 232 deMemset(&overlapped, 0, sizeof(overlapped)); 233 overlapped.hEvent = ioEvent.getHandle(); 234 235 for (;;) 236 { 237 DWORD numBytesRead = 0; 238 DWORD waitRes; 239 240 overlapped.Offset = (DWORD)(offset & 0xffffffffu); 241 overlapped.OffsetHigh = (DWORD)(offset >> 32); 242 243 if (!ReadFile(m_handle, &tmpBuf[0], (DWORD)tmpBuf.size(), NULL, &overlapped)) 244 { 245 DWORD err = GetLastError(); 246 247 if (err == ERROR_BROKEN_PIPE) 248 break; 249 else if (err == ERROR_HANDLE_EOF) 250 { 251 if (m_dstBuf->isCanceled()) 252 break; 253 254 deSleep(FILEREADER_IDLE_SLEEP); 255 256 if (m_dstBuf->isCanceled()) 257 break; 258 else 259 continue; 260 } 261 else if (err != ERROR_IO_PENDING) 262 throw Error(err, "ReadFile() failed"); 263 } 264 265 waitRes = WaitForMultipleObjects(DE_LENGTH_OF_ARRAY(waitHandles), &waitHandles[0], FALSE, INFINITE); 266 267 if (waitRes == WAIT_OBJECT_0) 268 { 269 // \note GetOverlappedResult() will fail with ERROR_IO_INCOMPLETE if IO event is not complete (should be). 270 if (!GetOverlappedResult(m_handle, &overlapped, &numBytesRead, FALSE)) 271 { 272 DWORD err = GetLastError(); 273 274 if (err == ERROR_HANDLE_EOF) 275 { 276 // End of file - for now. 277 // \note Should check for end of buffer here, or otherwise may end up in infinite loop. 278 if (m_dstBuf->isCanceled()) 279 break; 280 281 deSleep(FILEREADER_IDLE_SLEEP); 282 283 if (m_dstBuf->isCanceled()) 284 break; 285 else 286 continue; 287 } 288 else if (err == ERROR_BROKEN_PIPE) 289 break; 290 else 291 throw Error(err, "GetOverlappedResult() failed"); 292 } 293 294 if (numBytesRead == 0) 295 throw Error(GetLastError(), "Reading from file failed"); 296 else 297 offset += (deUint64)numBytesRead; 298 } 299 else if (waitRes == WAIT_OBJECT_0 + 1) 300 { 301 // Cancel. 302 if (!CancelIo(m_handle)) 303 throw Error(GetLastError(), "CancelIo() failed"); 304 break; 305 } 306 else 307 throw Error(GetLastError(), "WaitForMultipleObjects() failed"); 308 309 try 310 { 311 m_dstBuf->write((int)numBytesRead, &tmpBuf[0]); 312 m_dstBuf->flush(); 313 } 314 catch (const ThreadedByteBuffer::CanceledException&) 315 { 316 // Canceled. 317 break; 318 } 319 } 320 } 321 catch (const std::exception& e) 322 { 323 // \todo [2013-08-13 pyry] What to do? 324 printf("win32::FileReader::run(): %s\n", e.what()); 325 } 326 } 327 328 void FileReader::stop (void) 329 { 330 if (!isStarted()) 331 return; // Nothing to do. 332 333 m_cancelEvent.setSignaled(); 334 335 // Join thread. 336 join(); 337 338 m_cancelEvent.reset(); 339 340 m_handle = INVALID_HANDLE_VALUE; 341 } 342 343 // TestLogReader 344 345 TestLogReader::TestLogReader (void) 346 : m_logBuffer (LOG_BUFFER_BLOCK_SIZE, LOG_BUFFER_NUM_BLOCKS) 347 , m_logFile (INVALID_HANDLE_VALUE) 348 , m_reader (&m_logBuffer) 349 { 350 } 351 352 TestLogReader::~TestLogReader (void) 353 { 354 if (m_logFile != INVALID_HANDLE_VALUE) 355 CloseHandle(m_logFile); 356 } 357 358 void TestLogReader::start (const char* filename) 359 { 360 DE_ASSERT(m_logFile == INVALID_HANDLE_VALUE && !m_reader.isStarted()); 361 362 m_logFile = CreateFile(filename, 363 GENERIC_READ, 364 FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE, 365 DE_NULL, 366 OPEN_EXISTING, 367 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, 368 DE_NULL); 369 370 if (m_logFile == INVALID_HANDLE_VALUE) 371 throw Error(GetLastError(), "Failed to open log file"); 372 373 m_reader.start(m_logFile); 374 } 375 376 void TestLogReader::stop (void) 377 { 378 if (!m_reader.isStarted()) 379 return; // Nothing to do. 380 381 m_logBuffer.cancel(); 382 m_reader.stop(); 383 384 CloseHandle(m_logFile); 385 m_logFile = INVALID_HANDLE_VALUE; 386 387 m_logBuffer.clear(); 388 } 389 390 // Process 391 392 Process::Process (void) 393 : m_state (STATE_NOT_STARTED) 394 , m_exitCode (0) 395 , m_standardIn (INVALID_HANDLE_VALUE) 396 , m_standardOut (INVALID_HANDLE_VALUE) 397 , m_standardErr (INVALID_HANDLE_VALUE) 398 { 399 deMemset(&m_procInfo, 0, sizeof(m_procInfo)); 400 } 401 402 Process::~Process (void) 403 { 404 try 405 { 406 if (isRunning()) 407 { 408 kill(); 409 waitForFinish(); 410 } 411 } 412 catch (...) 413 { 414 } 415 416 cleanupHandles(); 417 } 418 419 void Process::cleanupHandles (void) 420 { 421 DE_ASSERT(!isRunning()); 422 423 if (m_standardErr != INVALID_HANDLE_VALUE) 424 CloseHandle(m_standardErr); 425 426 if (m_standardOut != INVALID_HANDLE_VALUE) 427 CloseHandle(m_standardOut); 428 429 if (m_standardIn != INVALID_HANDLE_VALUE) 430 CloseHandle(m_standardIn); 431 432 if (m_procInfo.hProcess) 433 CloseHandle(m_procInfo.hProcess); 434 435 if (m_procInfo.hThread) 436 CloseHandle(m_procInfo.hThread); 437 438 m_standardErr = INVALID_HANDLE_VALUE; 439 m_standardOut = INVALID_HANDLE_VALUE; 440 m_standardIn = INVALID_HANDLE_VALUE; 441 442 deMemset(&m_procInfo, 0, sizeof(m_procInfo)); 443 } 444 445 __declspec(thread) static int t_pipeNdx = 0; 446 447 static void createPipeWithOverlappedIO (HANDLE* readHandleOut, HANDLE* writeHandleOut, deUint32 readMode, deUint32 writeMode, SECURITY_ATTRIBUTES* securityAttr) 448 { 449 const int defaultBufSize = 4096; 450 char pipeName[128]; 451 HANDLE readHandle; 452 HANDLE writeHandle; 453 454 DE_ASSERT(((readMode | writeMode) & ~FILE_FLAG_OVERLAPPED) == 0); 455 456 deSprintf(pipeName, sizeof(pipeName), "\\\\.\\Pipe\\dEQP-ExecServer-%08x-%08x-%08x", 457 GetCurrentProcessId(), 458 GetCurrentThreadId(), 459 t_pipeNdx++); 460 461 readHandle = CreateNamedPipe(pipeName, /* Pipe name. */ 462 PIPE_ACCESS_INBOUND|readMode, /* Open mode. */ 463 PIPE_TYPE_BYTE|PIPE_WAIT, /* Pipe flags. */ 464 1, /* Max number of instances. */ 465 defaultBufSize, /* Output buffer size. */ 466 defaultBufSize, /* Input buffer size. */ 467 0, /* Use default timeout. */ 468 securityAttr); 469 470 if (readHandle == INVALID_HANDLE_VALUE) 471 throw Error(GetLastError(), "CreateNamedPipe() failed"); 472 473 writeHandle = CreateFile(pipeName, 474 GENERIC_WRITE, /* Access mode. */ 475 0, /* No sharing. */ 476 securityAttr, 477 OPEN_EXISTING, /* Assume existing object. */ 478 FILE_ATTRIBUTE_NORMAL|writeMode, /* Open mode / flags. */ 479 DE_NULL /* Template file. */); 480 481 if (writeHandle == INVALID_HANDLE_VALUE) 482 { 483 DWORD openErr = GetLastError(); 484 CloseHandle(readHandle); 485 throw Error(openErr, "Failed to open created pipe, CreateFile() failed"); 486 } 487 488 *readHandleOut = readHandle; 489 *writeHandleOut = writeHandle; 490 } 491 492 void Process::start (const char* commandLine, const char* workingDirectory) 493 { 494 // Pipes. 495 HANDLE stdInRead = INVALID_HANDLE_VALUE; 496 HANDLE stdInWrite = INVALID_HANDLE_VALUE; 497 HANDLE stdOutRead = INVALID_HANDLE_VALUE; 498 HANDLE stdOutWrite = INVALID_HANDLE_VALUE; 499 HANDLE stdErrRead = INVALID_HANDLE_VALUE; 500 HANDLE stdErrWrite = INVALID_HANDLE_VALUE; 501 502 if (m_state == STATE_RUNNING) 503 throw std::runtime_error("Process already running"); 504 else if (m_state == STATE_FINISHED) 505 { 506 // Process finished, clean up old cruft. 507 cleanupHandles(); 508 m_state = STATE_NOT_STARTED; 509 } 510 511 // Create pipes 512 try 513 { 514 SECURITY_ATTRIBUTES securityAttr; 515 STARTUPINFO startInfo; 516 517 deMemset(&startInfo, 0, sizeof(startInfo)); 518 deMemset(&securityAttr, 0, sizeof(securityAttr)); 519 520 // Security attributes for inheriting handle. 521 securityAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 522 securityAttr.bInheritHandle = TRUE; 523 securityAttr.lpSecurityDescriptor = DE_NULL; 524 525 createPipeWithOverlappedIO(&stdInRead, &stdInWrite, 0, FILE_FLAG_OVERLAPPED, &securityAttr); 526 createPipeWithOverlappedIO(&stdOutRead, &stdOutWrite, FILE_FLAG_OVERLAPPED, 0, &securityAttr); 527 createPipeWithOverlappedIO(&stdErrRead, &stdErrWrite, FILE_FLAG_OVERLAPPED, 0, &securityAttr); 528 529 if (!SetHandleInformation(stdInWrite, HANDLE_FLAG_INHERIT, 0) || 530 !SetHandleInformation(stdOutRead, HANDLE_FLAG_INHERIT, 0) || 531 !SetHandleInformation(stdErrRead, HANDLE_FLAG_INHERIT, 0)) 532 throw Error(GetLastError(), "SetHandleInformation() failed"); 533 534 // Startup info for process. 535 startInfo.cb = sizeof(startInfo); 536 startInfo.hStdError = stdErrWrite; 537 startInfo.hStdOutput = stdOutWrite; 538 startInfo.hStdInput = stdInRead; 539 startInfo.dwFlags |= STARTF_USESTDHANDLES; 540 541 if (!CreateProcess(DE_NULL, (LPTSTR)commandLine, DE_NULL, DE_NULL, TRUE /* inherit handles */, 0, DE_NULL, workingDirectory, &startInfo, &m_procInfo)) 542 throw Error(GetLastError(), "CreateProcess() failed"); 543 } 544 catch (...) 545 { 546 if (stdInRead != INVALID_HANDLE_VALUE) CloseHandle(stdInRead); 547 if (stdInWrite != INVALID_HANDLE_VALUE) CloseHandle(stdInWrite); 548 if (stdOutRead != INVALID_HANDLE_VALUE) CloseHandle(stdOutRead); 549 if (stdOutWrite != INVALID_HANDLE_VALUE) CloseHandle(stdOutWrite); 550 if (stdErrRead != INVALID_HANDLE_VALUE) CloseHandle(stdErrRead); 551 if (stdErrWrite != INVALID_HANDLE_VALUE) CloseHandle(stdErrWrite); 552 throw; 553 } 554 555 // Store handles to be kept. 556 m_standardIn = stdInWrite; 557 m_standardOut = stdOutRead; 558 m_standardErr = stdErrRead; 559 560 // Close other ends of handles. 561 CloseHandle(stdErrWrite); 562 CloseHandle(stdOutWrite); 563 CloseHandle(stdInRead); 564 565 m_state = STATE_RUNNING; 566 } 567 568 bool Process::isRunning (void) 569 { 570 if (m_state == STATE_RUNNING) 571 { 572 int exitCode; 573 BOOL result = GetExitCodeProcess(m_procInfo.hProcess, (LPDWORD)&exitCode); 574 575 if (result != TRUE) 576 throw Error(GetLastError(), "GetExitCodeProcess() failed"); 577 578 if (exitCode == STILL_ACTIVE) 579 return true; 580 else 581 { 582 // Done. 583 m_exitCode = exitCode; 584 m_state = STATE_FINISHED; 585 return false; 586 } 587 } 588 else 589 return false; 590 } 591 592 void Process::waitForFinish (void) 593 { 594 if (m_state == STATE_RUNNING) 595 { 596 if (WaitForSingleObject(m_procInfo.hProcess, INFINITE) != WAIT_OBJECT_0) 597 throw Error(GetLastError(), "Waiting for process failed, WaitForSingleObject() failed"); 598 599 if (isRunning()) 600 throw std::runtime_error("Process is still alive"); 601 } 602 else 603 throw std::runtime_error("Process is not running"); 604 } 605 606 void Process::stopProcess (bool kill) 607 { 608 if (m_state == STATE_RUNNING) 609 { 610 if (!TerminateProcess(m_procInfo.hProcess, kill ? -1 : 0)) 611 throw Error(GetLastError(), "TerminateProcess() failed"); 612 } 613 else 614 throw std::runtime_error("Process is not running"); 615 } 616 617 void Process::terminate (void) 618 { 619 stopProcess(false); 620 } 621 622 void Process::kill (void) 623 { 624 stopProcess(true); 625 } 626 627 } // win32 628 629 Win32TestProcess::Win32TestProcess (void) 630 : m_process (DE_NULL) 631 , m_processStartTime (0) 632 , m_infoBuffer (INFO_BUFFER_BLOCK_SIZE, INFO_BUFFER_NUM_BLOCKS) 633 , m_stdOutReader (&m_infoBuffer) 634 , m_stdErrReader (&m_infoBuffer) 635 { 636 } 637 638 Win32TestProcess::~Win32TestProcess (void) 639 { 640 delete m_process; 641 } 642 643 void Win32TestProcess::start (const char* name, const char* params, const char* workingDir, const char* caseList) 644 { 645 bool hasCaseList = strlen(caseList) > 0; 646 647 XS_CHECK(!m_process); 648 649 de::FilePath logFilePath = de::FilePath::join(workingDir, "TestResults.qpa"); 650 m_logFileName = logFilePath.getPath(); 651 652 // Remove old file if such exists. 653 // \note Sometimes on Windows the test process dies slowly and may not release handle to log file 654 // until a bit later. 655 // \todo [2013-07-15 pyry] This should be solved by improving deProcess and killing all child processes as well. 656 { 657 int tryNdx = 0; 658 while (tryNdx < MAX_OLD_LOGFILE_DELETE_ATTEMPTS && deFileExists(m_logFileName.c_str())) 659 { 660 if (deDeleteFile(m_logFileName.c_str())) 661 break; 662 deSleep(LOGFILE_DELETE_SLEEP_MS); 663 tryNdx += 1; 664 } 665 666 if (deFileExists(m_logFileName.c_str())) 667 throw TestProcessException(string("Failed to remove '") + m_logFileName + "'"); 668 } 669 670 // Construct command line. 671 string cmdLine = de::FilePath(name).isAbsolutePath() ? name : de::FilePath::join(workingDir, name).normalize().getPath(); 672 cmdLine += string(" --deqp-log-filename=") + logFilePath.getBaseName(); 673 674 if (hasCaseList) 675 cmdLine += " --deqp-stdin-caselist"; 676 677 if (strlen(params) > 0) 678 cmdLine += string(" ") + params; 679 680 DE_ASSERT(!m_process); 681 m_process = new win32::Process(); 682 683 try 684 { 685 m_process->start(cmdLine.c_str(), strlen(workingDir) > 0 ? workingDir : DE_NULL); 686 } 687 catch (const std::exception& e) 688 { 689 delete m_process; 690 m_process = DE_NULL; 691 throw TestProcessException(e.what()); 692 } 693 694 m_processStartTime = deGetMicroseconds(); 695 696 // Create stdout & stderr readers. 697 m_stdOutReader.start(m_process->getStdOut()); 698 m_stdErrReader.start(m_process->getStdErr()); 699 700 // Start case list writer. 701 if (hasCaseList) 702 m_caseListWriter.start(caseList, m_process->getStdIn()); 703 } 704 705 void Win32TestProcess::terminate (void) 706 { 707 if (m_process) 708 { 709 try 710 { 711 m_process->kill(); 712 } 713 catch (const std::exception& e) 714 { 715 printf("Win32TestProcess::terminate(): Failed to kill process: %s\n", e.what()); 716 } 717 } 718 } 719 720 void Win32TestProcess::cleanup (void) 721 { 722 m_caseListWriter.stop(); 723 724 // \note Buffers must be canceled before stopping readers. 725 m_infoBuffer.cancel(); 726 727 m_stdErrReader.stop(); 728 m_stdOutReader.stop(); 729 m_testLogReader.stop(); 730 731 // Reset buffers. 732 m_infoBuffer.clear(); 733 734 if (m_process) 735 { 736 try 737 { 738 if (m_process->isRunning()) 739 { 740 m_process->kill(); 741 m_process->waitForFinish(); 742 } 743 } 744 catch (const std::exception& e) 745 { 746 printf("Win32TestProcess::cleanup(): Failed to kill process: %s\n", e.what()); 747 } 748 749 delete m_process; 750 m_process = DE_NULL; 751 } 752 } 753 754 int Win32TestProcess::readTestLog (deUint8* dst, int numBytes) 755 { 756 if (!m_testLogReader.isRunning()) 757 { 758 if (deGetMicroseconds() - m_processStartTime > LOG_FILE_TIMEOUT*1000) 759 { 760 // Timeout, kill process. 761 terminate(); 762 return 0; // \todo [2013-08-13 pyry] Throw exception? 763 } 764 765 if (!deFileExists(m_logFileName.c_str())) 766 return 0; 767 768 // Start reader. 769 m_testLogReader.start(m_logFileName.c_str()); 770 } 771 772 DE_ASSERT(m_testLogReader.isRunning()); 773 return m_testLogReader.read(dst, numBytes); 774 } 775 776 bool Win32TestProcess::isRunning (void) 777 { 778 if (m_process) 779 return m_process->isRunning(); 780 else 781 return false; 782 } 783 784 int Win32TestProcess::getExitCode (void) const 785 { 786 if (m_process) 787 return m_process->getExitCode(); 788 else 789 return -1; 790 } 791 792 } // xs 793
