Merge "Add the support to device connection via TCP/IP" into marshmallow-cts-dev
[platform/upstream/VK-GL-CTS.git] / execserver / xsProtocol.hpp
1 #ifndef _XSPROTOCOL_HPP
2 #define _XSPROTOCOL_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 Execution Server Protocol.
24  *//*--------------------------------------------------------------------*/
25
26 #include "xsDefs.hpp"
27 #include "deMemory.h"
28
29 #include <string>
30 #include <vector>
31
32 namespace xs
33 {
34
35 enum
36 {
37         PROTOCOL_VERSION                        = 18,
38         MESSAGE_HEADER_SIZE                     = 8,
39
40         // Times are in milliseconds.
41         KEEPALIVE_SEND_INTERVAL         = 5000,
42         KEEPALIVE_TIMEOUT                       = 30000,
43 };
44
45 enum MessageType
46 {
47         MESSAGETYPE_NONE                                        = 0,    //!< Not valid.
48
49         // Commands (from Client to ExecServer).
50         MESSAGETYPE_HELLO                                       = 100,  //!< First message from client, specifies the protocol version
51         MESSAGETYPE_TEST                                        = 101,  //!< Debug only
52         MESSAGETYPE_EXECUTE_BINARY                      = 111,  //!< Request execution of a test package binary.
53         MESSAGETYPE_STOP_EXECUTION                      = 112,  //!< Request cancellation of the currently executing binary.
54
55         // Responses (from ExecServer to Client)
56         MESSAGETYPE_PROCESS_STARTED                     = 200,  //!< Requested process has started.
57         MESSAGETYPE_PROCESS_LAUNCH_FAILED       = 201,  //!< Requested process failed to launch.
58         MESSAGETYPE_PROCESS_FINISHED            = 202,  //!< Requested process has finished (for any reason).
59         MESSAGETYPE_PROCESS_LOG_DATA            = 203,  //!< Unprocessed log data from TestResults.qpa.
60         MESSAGETYPE_INFO                                        = 204,  //!< Generic info message from ExecServer (for debugging purposes).
61
62         MESSAGETYPE_KEEPALIVE                           = 102   //!< Keep-alive packet
63 };
64
65 class MessageWriter;
66
67 class Message
68 {
69 public:
70         MessageType             type;
71
72                                         Message                 (MessageType type_) : type(type_) {}
73         virtual                  ~Message               (void) {}
74
75         virtual void    write                   (std::vector<deUint8>& buf) const = DE_NULL;
76
77         static void             parseHeader             (const deUint8* data, size_t dataSize, MessageType& type, size_t& messageSize);
78         static void             writeHeader             (MessageType type, size_t messageSize, deUint8* dst, size_t bufSize);
79
80 protected:
81         void                    writeNoData             (std::vector<deUint8>& buf) const;
82
83                                         Message                 (const Message& other);
84         Message&                operator=               (const Message& other);
85 };
86
87 // Simple messages without any data.
88 template <int MsgType>
89 class SimpleMessage : public Message
90 {
91 public:
92                                         SimpleMessage   (const deUint8* data, size_t dataSize) : Message((MessageType)MsgType) { DE_UNREF(data); XS_CHECK_MSG(dataSize == 0, "No payload expected"); }
93                                         SimpleMessage   (void) : Message((MessageType)MsgType) {}
94                                         ~SimpleMessage  (void) {}
95
96         void                    write                   (std::vector<deUint8>& buf) const { writeNoData(buf); }
97 };
98
99 typedef SimpleMessage<MESSAGETYPE_STOP_EXECUTION>                       StopExecutionMessage;
100 typedef SimpleMessage<MESSAGETYPE_PROCESS_STARTED>                      ProcessStartedMessage;
101 typedef SimpleMessage<MESSAGETYPE_KEEPALIVE>                            KeepAliveMessage;
102
103 class HelloMessage : public Message
104 {
105 public:
106         int                             version;
107
108                                         HelloMessage    (const deUint8* data, size_t dataSize);
109                                         HelloMessage    (void) : Message(MESSAGETYPE_HELLO), version(PROTOCOL_VERSION) {}
110                                         ~HelloMessage   (void) {}
111
112         void                    write                   (std::vector<deUint8>& buf) const;
113 };
114
115 class ExecuteBinaryMessage : public Message
116 {
117 public:
118         std::string             name;
119         std::string             params;
120         std::string             workDir;
121         std::string             caseList;
122
123                                         ExecuteBinaryMessage    (const deUint8* data, size_t dataSize);
124                                         ExecuteBinaryMessage    (void) : Message(MESSAGETYPE_EXECUTE_BINARY) {}
125                                         ~ExecuteBinaryMessage   (void) {};
126
127         void                    write                   (std::vector<deUint8>& buf) const;
128 };
129
130 class ProcessLogDataMessage : public Message
131 {
132 public:
133         std::string             logData;
134
135                                         ProcessLogDataMessage           (const deUint8* data, size_t dataSize);
136                                         ~ProcessLogDataMessage          (void) {}
137
138         void                    write                                           (std::vector<deUint8>& buf) const;
139 };
140
141 class ProcessLaunchFailedMessage : public Message
142 {
143 public:
144         std::string             reason;
145
146                                         ProcessLaunchFailedMessage                      (const deUint8* data, size_t dataSize);
147                                         ProcessLaunchFailedMessage                      (const char* reason_) : Message(MESSAGETYPE_PROCESS_LAUNCH_FAILED), reason(reason_) {}
148                                         ~ProcessLaunchFailedMessage                     (void) {}
149
150         void                    write                                                           (std::vector<deUint8>& buf) const;
151 };
152
153 class ProcessFinishedMessage : public Message
154 {
155 public:
156         int                             exitCode;
157
158                                         ProcessFinishedMessage                  (const deUint8* data, size_t dataSize);
159                                         ProcessFinishedMessage                  (int exitCode_) : Message(MESSAGETYPE_PROCESS_FINISHED), exitCode(exitCode_) {}
160                                         ~ProcessFinishedMessage                 (void) {}
161
162         void                    write                                                   (std::vector<deUint8>& buf) const;
163 };
164
165 class InfoMessage : public Message
166 {
167 public:
168         std::string             info;
169
170                                         InfoMessage                     (const deUint8* data, size_t dataSize);
171                                         ~InfoMessage            (void) {}
172
173         void                    write                           (std::vector<deUint8>& buf) const;
174 };
175
176 // For debug purposes only.
177 class TestMessage : public Message
178 {
179 public:
180         std::string             test;
181
182                                         TestMessage             (const deUint8* data, size_t dataSize);
183                                         ~TestMessage    (void) {}
184
185         void                    write                   (std::vector<deUint8>& buf) const;
186 };
187
188 } // xs
189
190 #endif // _XSPROTOCOL_HPP