Merge "Fix extension support checks in negative api tests" into nougat-cts-dev am...
[platform/upstream/VK-GL-CTS.git] / execserver / xsExecutionServer.hpp
1 #ifndef _XSEXECUTIONSERVER_HPP
2 #define _XSEXECUTIONSERVER_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Execution Server
5  * ---------------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief Test Execution Server.
24  *//*--------------------------------------------------------------------*/
25
26 #include "xsDefs.hpp"
27 #include "xsTcpServer.hpp"
28 #include "xsTestDriver.hpp"
29 #include "xsProtocol.hpp"
30 #include "xsTestProcess.hpp"
31
32 #include <vector>
33
34 namespace xs
35 {
36
37 class ExecutionServer : public TcpServer
38 {
39 public:
40         enum RunMode
41         {
42                 RUNMODE_SINGLE_EXEC     = 0,
43                 RUNMODE_FOREVER,
44
45                 RUNMODE_LAST
46         };
47
48                                                         ExecutionServer                 (xs::TestProcess* testProcess, deSocketFamily family, int port, RunMode runMode);
49                                                         ~ExecutionServer                (void);
50
51         ConnectionHandler*              createHandler                   (de::Socket* socket, const de::SocketAddress& clientAddress);
52
53         TestDriver*                             acquireTestDriver               (void);
54         void                                    releaseTestDriver               (TestDriver* driver);
55
56         void                                    connectionDone                  (ConnectionHandler* handler);
57
58 private:
59         TestDriver                              m_testDriver;
60         de::Mutex                               m_testDriverLock;
61         RunMode                                 m_runMode;
62 };
63
64 class MessageBuilder
65 {
66 public:
67                                                         MessageBuilder          (void) { clear(); }
68                                                         ~MessageBuilder         (void) {}
69
70         void                                    read                            (ByteBuffer& buffer);
71         void                                    clear                           (void);
72
73         bool                                    isComplete                      (void) const;
74         MessageType                             getMessageType          (void) const    { return m_messageType; }
75         size_t                                  getMessageSize          (void) const    { return m_messageSize; }
76         const deUint8*                  getMessageData          (void) const;
77         size_t                                  getMessageDataSize      (void) const;
78
79 private:
80         std::vector<deUint8>    m_buffer;
81         MessageType                             m_messageType;
82         size_t                                  m_messageSize;
83 };
84
85 class ExecutionRequestHandler : public ConnectionHandler
86 {
87 public:
88                                                                 ExecutionRequestHandler                 (ExecutionServer* server, de::Socket* socket);
89                                                                 ~ExecutionRequestHandler                (void);
90
91 protected:
92         void                                            handle                                                  (void);
93
94 private:
95                                                                 ExecutionRequestHandler                 (const ExecutionRequestHandler& handler);
96         ExecutionRequestHandler&        operator=                                               (const ExecutionRequestHandler& handler);
97
98         void                                            processSession                                  (void);
99         void                                            processMessage                                  (MessageType type, const deUint8* data, size_t dataSize);
100
101         inline TestDriver*                      getTestDriver                                   (void) { if (!m_testDriver) acquireTestDriver(); return m_testDriver; }
102         void                                            acquireTestDriver                               (void);
103
104         void                                            initKeepAlives                                  (void);
105         void                                            keepAliveReceived                               (void);
106         void                                            pollKeepAlives                                  (void);
107
108         bool                                            receive                                                 (void);
109         bool                                            send                                                    (void);
110
111         ExecutionServer*                        m_execServer;
112         TestDriver*                                     m_testDriver;
113
114         ByteBuffer                                      m_bufferIn;
115         ByteBuffer                                      m_bufferOut;
116
117         bool                                            m_run;
118         MessageBuilder                          m_msgBuilder;
119
120         // \todo [2011-09-30 pyry] Move to some watchdog class instead.
121         deUint64                                        m_lastKeepAliveSent;
122         deUint64                                        m_lastKeepAliveReceived;
123
124         std::vector<deUint8>            m_sendRecvTmpBuf;
125 };
126
127 } // xs
128
129 #endif // _XSEXECUTIONSERVER_HPP