xref: /external/deqp/execserver/xsWin32TestProcess.hpp

#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