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 Test Driver. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "xsTestDriver.hpp" 25 #include "deClock.h" 26 27 #include <string> 28 #include <vector> 29 #include <cstdio> 30 31 using std::string; 32 using std::vector; 33 34 #if 0 35 # define DBG_PRINT(X) printf X 36 #else 37 # define DBG_PRINT(X) 38 #endif 39 40 namespace xs 41 { 42 43 TestDriver::TestDriver (xs::TestProcess* testProcess) 44 : m_state (STATE_NOT_STARTED) 45 , m_lastExitCode (0) 46 , m_process (testProcess) 47 , m_lastProcessDataTime (0) 48 , m_dataMsgTmpBuf (SEND_RECV_TMP_BUFFER_SIZE) 49 { 50 } 51 52 TestDriver::~TestDriver (void) 53 { 54 reset(); 55 } 56 57 void TestDriver::reset (void) 58 { 59 m_process->cleanup(); 60 61 m_state = STATE_NOT_STARTED; 62 } 63 64 void TestDriver::startProcess (const char* name, const char* params, const char* workingDir, const char* caseList) 65 { 66 try 67 { 68 m_process->start(name, params, workingDir, caseList); 69 m_state = STATE_PROCESS_STARTED; 70 } 71 catch (const TestProcessException& e) 72 { 73 printf("Failed to launch test process: %s\n", e.what()); 74 m_state = STATE_PROCESS_LAUNCH_FAILED; 75 m_lastLaunchFailure = e.what(); 76 } 77 } 78 79 void TestDriver::stopProcess (void) 80 { 81 m_process->terminate(); 82 } 83 84 bool TestDriver::poll (ByteBuffer& messageBuffer) 85 { 86 switch (m_state) 87 { 88 case STATE_NOT_STARTED: 89 return false; // Nothing to report. 90 91 case STATE_PROCESS_LAUNCH_FAILED: 92 DBG_PRINT((" STATE_PROCESS_LAUNCH_FAILED\n")); 93 if (writeMessage(messageBuffer, ProcessLaunchFailedMessage(m_lastLaunchFailure.c_str()))) 94 { 95 m_state = STATE_NOT_STARTED; 96 m_lastLaunchFailure = ""; 97 return true; 98 } 99 else 100 return false; 101 102 case STATE_PROCESS_STARTED: 103 DBG_PRINT((" STATE_PROCESS_STARTED\n")); 104 if (writeMessage(messageBuffer, ProcessStartedMessage())) 105 { 106 m_state = STATE_PROCESS_RUNNING; 107 return true; 108 } 109 else 110 return false; 111 112 case STATE_PROCESS_RUNNING: 113 { 114 DBG_PRINT((" STATE_PROCESS_RUNNING\n")); 115 bool gotProcessData = false; 116 117 // Poll log file and info buffer. 118 gotProcessData = pollLogFile(messageBuffer) || gotProcessData; 119 gotProcessData = pollInfo(messageBuffer) || gotProcessData; 120 121 if (gotProcessData) 122 return true; // Got IO. 123 124 if (!m_process->isRunning()) 125 { 126 // Process died. 127 m_state = STATE_READING_DATA; 128 m_lastExitCode = m_process->getExitCode(); 129 m_lastProcessDataTime = deGetMicroseconds(); 130 131 return true; // Got state change. 132 } 133 134 return false; // Nothing to report. 135 } 136 137 case STATE_READING_DATA: 138 { 139 DBG_PRINT((" STATE_READING_DATA\n")); 140 bool gotProcessData = false; 141 142 // Poll log file and info buffer. 143 gotProcessData = pollLogFile(messageBuffer) || gotProcessData; 144 gotProcessData = pollInfo(messageBuffer) || gotProcessData; 145 146 if (gotProcessData) 147 { 148 // Got data. 149 m_lastProcessDataTime = deGetMicroseconds(); 150 return true; 151 } 152 else if (deGetMicroseconds() - m_lastProcessDataTime > READ_DATA_TIMEOUT*1000) 153 { 154 // Read timeout occurred. 155 m_state = STATE_PROCESS_FINISHED; 156 return true; // State change. 157 } 158 else 159 return false; // Still waiting for data. 160 } 161 162 case STATE_PROCESS_FINISHED: 163 DBG_PRINT((" STATE_PROCESS_FINISHED\n")); 164 if (writeMessage(messageBuffer, ProcessFinishedMessage(m_lastExitCode))) 165 { 166 // Signal TestProcess to clean up any remaining resources. 167 m_process->cleanup(); 168 169 m_state = STATE_NOT_STARTED; 170 m_lastExitCode = 0; 171 return true; 172 } 173 else 174 return false; 175 176 default: 177 DE_ASSERT(DE_FALSE); 178 return false; 179 } 180 } 181 182 bool TestDriver::pollLogFile (ByteBuffer& messageBuffer) 183 { 184 return pollBuffer(messageBuffer, MESSAGETYPE_PROCESS_LOG_DATA); 185 } 186 187 bool TestDriver::pollInfo (ByteBuffer& messageBuffer) 188 { 189 return pollBuffer(messageBuffer, MESSAGETYPE_INFO); 190 } 191 192 bool TestDriver::pollBuffer (ByteBuffer& messageBuffer, MessageType msgType) 193 { 194 const int minBytesAvailable = MESSAGE_HEADER_SIZE + MIN_MSG_PAYLOAD_SIZE; 195 196 if (messageBuffer.getNumFree() < minBytesAvailable) 197 return false; // Not enough space in message buffer. 198 199 const int maxMsgSize = de::min((int)m_dataMsgTmpBuf.size(), messageBuffer.getNumFree()); 200 int numRead = 0; 201 int msgSize = MESSAGE_HEADER_SIZE+1; // One byte is reserved for terminating 0. 202 203 // Fill in data \note Last byte is reserved for 0. 204 numRead = msgType == MESSAGETYPE_PROCESS_LOG_DATA 205 ? m_process->readTestLog(&m_dataMsgTmpBuf[MESSAGE_HEADER_SIZE], maxMsgSize-MESSAGE_HEADER_SIZE-1) 206 : m_process->readInfoLog(&m_dataMsgTmpBuf[MESSAGE_HEADER_SIZE], maxMsgSize-MESSAGE_HEADER_SIZE-1); 207 208 if (numRead <= 0) 209 return false; // Didn't get any data. 210 211 msgSize += numRead; 212 213 // Terminate with 0. 214 m_dataMsgTmpBuf[msgSize-1] = 0; 215 216 // Write header. 217 Message::writeHeader(msgType, msgSize, &m_dataMsgTmpBuf[0], MESSAGE_HEADER_SIZE); 218 219 // Write to messagebuffer. 220 messageBuffer.pushFront(&m_dataMsgTmpBuf[0], msgSize); 221 222 DBG_PRINT((" wrote %d bytes of %s data\n", msgSize, msgType == MESSAGETYPE_INFO ? "info" : "log")); 223 224 return true; 225 } 226 227 bool TestDriver::writeMessage (ByteBuffer& messageBuffer, const Message& message) 228 { 229 vector<deUint8> buf; 230 message.write(buf); 231 232 if (messageBuffer.getNumFree() < (int)buf.size()) 233 return false; 234 235 messageBuffer.pushFront(&buf[0], (int)buf.size()); 236 return true; 237 } 238 239 } // xs 240
