blob: b7acf89ff27001dc704fdcf618aeada11b584428 [file] [log] [blame] [edit]
#ifndef _XSWIN32TESTPROCESS_HPP
#define _XSWIN32TESTPROCESS_HPP
/*-------------------------------------------------------------------------
* 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 "xsDefs.hpp"
#include "xsTestProcess.hpp"
#include "deThread.hpp"
#include <vector>
#include <string>
#if !defined(VC_EXTRALEAN)
# define VC_EXTRALEAN 1
#endif
#if !defined(WIN32_LEAN_AND_MEAN)
# define WIN32_LEAN_AND_MEAN 1
#endif
#if !defined(NOMINMAX)
# define NOMINMAX 1
#endif
#include <windows.h>
namespace xs
{
namespace win32
{
class Error : public std::runtime_error
{
public:
Error (DWORD error, const char* msg);
private:
DWORD m_error;
};
class Event
{
public:
Event (bool manualReset, bool initialState);
~Event (void);
void setSignaled (void);
void reset (void);
HANDLE getHandle (void) const { return m_handle; }
private:
Event (const Event& other);
Event& operator= (const Event& other);
HANDLE m_handle;
};
class CaseListWriter : public de::Thread
{
public:
CaseListWriter (void);
~CaseListWriter (void);
void start (const char* caseList, HANDLE dst);
void stop (void);
void run (void);
private:
std::vector<char> m_caseList;
HANDLE m_dst;
Event m_cancelEvent;
};
class FileReader : public de::Thread
{
public:
FileReader (ThreadedByteBuffer* dst);
~FileReader (void);
void start (HANDLE file);
void stop (void);
void run (void);
private:
ThreadedByteBuffer* m_dstBuf;
HANDLE m_handle;
Event m_cancelEvent;
};
class TestLogReader
{
public:
TestLogReader (void);
~TestLogReader (void);
void start (const char* filename);
void stop (void);
bool isRunning (void) const { return m_reader.isStarted(); }
int read (deUint8* dst, int numBytes) { return m_logBuffer.tryRead(numBytes, dst); }
private:
ThreadedByteBuffer m_logBuffer;
HANDLE m_logFile;
FileReader m_reader;
};
// \note deProcess uses anonymous pipes that don't have overlapped IO available.
// For ExecServer purposes we need overlapped IO, and it makes the handles
// incompatible with deFile. Thus separate Process implementation is used for now.
class Process
{
public:
Process (void);
~Process (void);
void start (const char* commandLine, const char* workingDirectory);
void waitForFinish (void);
void terminate (void);
void kill (void);
bool isRunning (void);
int getExitCode (void) const { return m_exitCode; }
HANDLE getStdIn (void) const { return m_standardIn; }
HANDLE getStdOut (void) const { return m_standardOut; }
HANDLE getStdErr (void) const { return m_standardErr; }
private:
Process (const Process& other);
Process& operator= (const Process& other);
void stopProcess (bool kill);
void cleanupHandles (void);
enum State
{
STATE_NOT_STARTED = 0,
STATE_RUNNING,
STATE_FINISHED,
STATE_LAST
};
State m_state;
int m_exitCode;
PROCESS_INFORMATION m_procInfo;
HANDLE m_standardIn;
HANDLE m_standardOut;
HANDLE m_standardErr;
};
} // win32
class Win32TestProcess : public TestProcess
{
public:
Win32TestProcess (void);
virtual ~Win32TestProcess (void);
virtual void start (const char* name, const char* params, const char* workingDir, const char* caseList);
virtual void terminate (void);
virtual void cleanup (void);
virtual bool isRunning (void);
virtual int getExitCode (void) const;
virtual int readTestLog (deUint8* dst, int numBytes);
virtual int readInfoLog (deUint8* dst, int numBytes) { return m_infoBuffer.tryRead(numBytes, dst); }
private:
Win32TestProcess (const Win32TestProcess& other);
Win32TestProcess& operator= (const Win32TestProcess& other);
win32::Process* m_process;
deUint64 m_processStartTime;
std::string m_logFileName;
ThreadedByteBuffer m_infoBuffer;
// Threads.
win32::CaseListWriter m_caseListWriter;
win32::FileReader m_stdOutReader;
win32::FileReader m_stdErrReader;
win32::TestLogReader m_testLogReader;
};
} // xs
#endif // _XSWIN32TESTPROCESS_HPP