/*-------------------------------------------------------------------------
|
* 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 Test Driver.
|
*//*--------------------------------------------------------------------*/
|
|
#include "xsTestDriver.hpp"
|
#include "deClock.h"
|
|
#include <string>
|
#include <vector>
|
#include <cstdio>
|
|
using std::string;
|
using std::vector;
|
|
#if 0
|
# define DBG_PRINT(X) printf X
|
#else
|
# define DBG_PRINT(X)
|
#endif
|
|
namespace xs
|
{
|
|
TestDriver::TestDriver (xs::TestProcess* testProcess)
|
: m_state (STATE_NOT_STARTED)
|
, m_lastExitCode (0)
|
, m_process (testProcess)
|
, m_lastProcessDataTime (0)
|
, m_dataMsgTmpBuf (SEND_RECV_TMP_BUFFER_SIZE)
|
{
|
}
|
|
TestDriver::~TestDriver (void)
|
{
|
reset();
|
}
|
|
void TestDriver::reset (void)
|
{
|
m_process->cleanup();
|
|
m_state = STATE_NOT_STARTED;
|
}
|
|
void TestDriver::startProcess (const char* name, const char* params, const char* workingDir, const char* caseList)
|
{
|
try
|
{
|
m_process->start(name, params, workingDir, caseList);
|
m_state = STATE_PROCESS_STARTED;
|
}
|
catch (const TestProcessException& e)
|
{
|
printf("Failed to launch test process: %s\n", e.what());
|
m_state = STATE_PROCESS_LAUNCH_FAILED;
|
m_lastLaunchFailure = e.what();
|
}
|
}
|
|
void TestDriver::stopProcess (void)
|
{
|
m_process->terminate();
|
}
|
|
bool TestDriver::poll (ByteBuffer& messageBuffer)
|
{
|
switch (m_state)
|
{
|
case STATE_NOT_STARTED:
|
return false; // Nothing to report.
|
|
case STATE_PROCESS_LAUNCH_FAILED:
|
DBG_PRINT((" STATE_PROCESS_LAUNCH_FAILED\n"));
|
if (writeMessage(messageBuffer, ProcessLaunchFailedMessage(m_lastLaunchFailure.c_str())))
|
{
|
m_state = STATE_NOT_STARTED;
|
m_lastLaunchFailure = "";
|
return true;
|
}
|
else
|
return false;
|
|
case STATE_PROCESS_STARTED:
|
DBG_PRINT((" STATE_PROCESS_STARTED\n"));
|
if (writeMessage(messageBuffer, ProcessStartedMessage()))
|
{
|
m_state = STATE_PROCESS_RUNNING;
|
return true;
|
}
|
else
|
return false;
|
|
case STATE_PROCESS_RUNNING:
|
{
|
DBG_PRINT((" STATE_PROCESS_RUNNING\n"));
|
bool gotProcessData = false;
|
|
// Poll log file and info buffer.
|
gotProcessData = pollLogFile(messageBuffer) || gotProcessData;
|
gotProcessData = pollInfo(messageBuffer) || gotProcessData;
|
|
if (gotProcessData)
|
return true; // Got IO.
|
|
if (!m_process->isRunning())
|
{
|
// Process died.
|
m_state = STATE_READING_DATA;
|
m_lastExitCode = m_process->getExitCode();
|
m_lastProcessDataTime = deGetMicroseconds();
|
|
return true; // Got state change.
|
}
|
|
return false; // Nothing to report.
|
}
|
|
case STATE_READING_DATA:
|
{
|
DBG_PRINT((" STATE_READING_DATA\n"));
|
bool gotProcessData = false;
|
|
// Poll log file and info buffer.
|
gotProcessData = pollLogFile(messageBuffer) || gotProcessData;
|
gotProcessData = pollInfo(messageBuffer) || gotProcessData;
|
|
if (gotProcessData)
|
{
|
// Got data.
|
m_lastProcessDataTime = deGetMicroseconds();
|
return true;
|
}
|
else if (deGetMicroseconds() - m_lastProcessDataTime > READ_DATA_TIMEOUT*1000)
|
{
|
// Read timeout occurred.
|
m_state = STATE_PROCESS_FINISHED;
|
return true; // State change.
|
}
|
else
|
return false; // Still waiting for data.
|
}
|
|
case STATE_PROCESS_FINISHED:
|
DBG_PRINT((" STATE_PROCESS_FINISHED\n"));
|
if (writeMessage(messageBuffer, ProcessFinishedMessage(m_lastExitCode)))
|
{
|
// Signal TestProcess to clean up any remaining resources.
|
m_process->cleanup();
|
|
m_state = STATE_NOT_STARTED;
|
m_lastExitCode = 0;
|
return true;
|
}
|
else
|
return false;
|
|
default:
|
DE_ASSERT(DE_FALSE);
|
return false;
|
}
|
}
|
|
bool TestDriver::pollLogFile (ByteBuffer& messageBuffer)
|
{
|
return pollBuffer(messageBuffer, MESSAGETYPE_PROCESS_LOG_DATA);
|
}
|
|
bool TestDriver::pollInfo (ByteBuffer& messageBuffer)
|
{
|
return pollBuffer(messageBuffer, MESSAGETYPE_INFO);
|
}
|
|
bool TestDriver::pollBuffer (ByteBuffer& messageBuffer, MessageType msgType)
|
{
|
const int minBytesAvailable = MESSAGE_HEADER_SIZE + MIN_MSG_PAYLOAD_SIZE;
|
|
if (messageBuffer.getNumFree() < minBytesAvailable)
|
return false; // Not enough space in message buffer.
|
|
const int maxMsgSize = de::min((int)m_dataMsgTmpBuf.size(), messageBuffer.getNumFree());
|
int numRead = 0;
|
int msgSize = MESSAGE_HEADER_SIZE+1; // One byte is reserved for terminating 0.
|
|
// Fill in data \note Last byte is reserved for 0.
|
numRead = msgType == MESSAGETYPE_PROCESS_LOG_DATA
|
? m_process->readTestLog(&m_dataMsgTmpBuf[MESSAGE_HEADER_SIZE], maxMsgSize-MESSAGE_HEADER_SIZE-1)
|
: m_process->readInfoLog(&m_dataMsgTmpBuf[MESSAGE_HEADER_SIZE], maxMsgSize-MESSAGE_HEADER_SIZE-1);
|
|
if (numRead <= 0)
|
return false; // Didn't get any data.
|
|
msgSize += numRead;
|
|
// Terminate with 0.
|
m_dataMsgTmpBuf[msgSize-1] = 0;
|
|
// Write header.
|
Message::writeHeader(msgType, msgSize, &m_dataMsgTmpBuf[0], MESSAGE_HEADER_SIZE);
|
|
// Write to messagebuffer.
|
messageBuffer.pushFront(&m_dataMsgTmpBuf[0], msgSize);
|
|
DBG_PRINT((" wrote %d bytes of %s data\n", msgSize, msgType == MESSAGETYPE_INFO ? "info" : "log"));
|
|
return true;
|
}
|
|
bool TestDriver::writeMessage (ByteBuffer& messageBuffer, const Message& message)
|
{
|
vector<deUint8> buf;
|
message.write(buf);
|
|
if (messageBuffer.getNumFree() < (int)buf.size())
|
return false;
|
|
messageBuffer.pushFront(&buf[0], (int)buf.size());
|
return true;
|
}
|
|
} // xs
|
