execserver/tools/xsClient.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Execution Server
   3  * ---------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief ExecServer Client.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "xsDefs.hpp"
  25 #include "xsProtocol.hpp"
  26 #include "deSocket.hpp"
  27 #include "deUniquePtr.hpp"
  28
  29 #include "deString.h"
  30
  31 #include <memory>
  32 #include <sstream>
  33 #include <fstream>
  34 #include <cstdio>
  35 #include <cstdlib>
  36
  37 using std::string;
  38 using std::vector;
  39
  40 namespace xs
  41 {
  42
  43 typedef de::UniquePtr<Message> ScopedMsgPtr;
  44
  45 class SocketError : public Error
  46 {
  47 public:
  48         SocketError (deSocketResult result, const char* message, const char* file, int line)
  49                 : Error         (message, deGetSocketResultName(result), file, line)
  50                 , m_result      (result)
  51         {
  52         }
  53
  54         deSocketResult getResult (void) const
  55         {
  56                 return m_result;
  57         }
  58
  59 private:
  60         deSocketResult m_result;
  61 };
  62
  63 // Helpers.
  64 void sendMessage (de::Socket& socket, const Message& message)
  65 {
  66         // Format message.
  67         vector<deUint8> buf;
  68         message.write(buf);
  69
  70         // Write to socket.
  71         size_t pos = 0;
  72         while (pos < buf.size())
  73         {
  74                 size_t                  numLeft         = buf.size() - pos;
  75                 size_t                  numSent         = 0;
  76                 deSocketResult  result          = socket.send(&buf[pos], numLeft, &numSent);
  77
  78                 if (result != DE_SOCKETRESULT_SUCCESS)
  79                         throw SocketError(result, "send() failed", __FILE__, __LINE__);
  80
  81                 pos += numSent;
  82         }
  83 }
  84
  85 void readBytes (de::Socket& socket, vector<deUint8>& dst, size_t numBytes)
  86 {
  87         size_t numRead = 0;
  88         dst.resize(numBytes);
  89         while (numRead < numBytes)
  90         {
  91                 size_t                  numLeft         = numBytes - numRead;
  92                 size_t                  curNumRead      = 0;
  93                 deSocketResult  result          = socket.receive(&dst[numRead], numLeft, &curNumRead);
  94
  95                 if (result != DE_SOCKETRESULT_SUCCESS)
  96                         throw SocketError(result, "receive() failed", __FILE__, __LINE__);
  97
  98                 numRead += curNumRead;
  99         }
 100 }
 101
 102 Message* readMessage (de::Socket& socket)
 103 {
 104         // Header.
 105         vector<deUint8> header;
 106         readBytes(socket, header, MESSAGE_HEADER_SIZE);
 107
 108         MessageType     type;
 109         size_t          messageSize;
 110         Message::parseHeader(&header[0], (int)header.size(), type, messageSize);
 111
 112         // Simple messages without any data.
 113         switch (type)
 114         {
 115                 case MESSAGETYPE_KEEPALIVE:                             return new KeepAliveMessage();
 116                 case MESSAGETYPE_PROCESS_STARTED:               return new ProcessStartedMessage();
 117                 default:
 118                         break; // Read message with data.
 119         }
 120
 121         vector<deUint8> messageBuf;
 122         readBytes(socket, messageBuf, messageSize-MESSAGE_HEADER_SIZE);
 123
 124         switch (type)
 125         {
 126                 case MESSAGETYPE_HELLO:                                 return new HelloMessage(&messageBuf[0], (int)messageBuf.size());
 127                 case MESSAGETYPE_TEST:                                  return new TestMessage(&messageBuf[0], (int)messageBuf.size());
 128                 case MESSAGETYPE_PROCESS_LOG_DATA:              return new ProcessLogDataMessage(&messageBuf[0], (int)messageBuf.size());
 129                 case MESSAGETYPE_INFO:                                  return new InfoMessage(&messageBuf[0], (int)messageBuf.size());
 130                 case MESSAGETYPE_PROCESS_LAUNCH_FAILED: return new ProcessLaunchFailedMessage(&messageBuf[0], (int)messageBuf.size());
 131                 case MESSAGETYPE_PROCESS_FINISHED:              return new ProcessFinishedMessage(&messageBuf[0], (int)messageBuf.size());
 132                 default:
 133                         XS_FAIL("Unknown message");
 134         }
 135 }
 136
 137 class CommandLine
 138 {
 139 public:
 140         de::SocketAddress       address;
 141         std::string                     program;
 142         std::string                     params;
 143         std::string                     workingDir;
 144         std::string                     caseList;
 145         std::string                     dstFileName;
 146 };
 147
 148 class Client
 149 {
 150 public:
 151                                                 Client          (const CommandLine& cmdLine);
 152                                                 ~Client         (void);
 153
 154         void                            run                     (void);
 155
 156 private:
 157         const CommandLine&      m_cmdLine;
 158         de::Socket                      m_socket;
 159 };
 160
 161 Client::Client (const CommandLine& cmdLine)
 162         : m_cmdLine(cmdLine)
 163 {
 164 }
 165
 166 Client::~Client (void)
 167 {
 168 }
 169
 170 void Client::run (void)
 171 {
 172         // Connect to server.
 173         m_socket.connect(m_cmdLine.address);
 174
 175         printf("Connected to %s:%d!\n", m_cmdLine.address.getHost(), m_cmdLine.address.getPort());
 176
 177         // Open result file.
 178         std::fstream out(m_cmdLine.dstFileName.c_str(), std::fstream::out|std::fstream::binary);
 179
 180         printf("  writing to %s\n", m_cmdLine.dstFileName.c_str());
 181
 182         // Send execution request.
 183         {
 184                 ExecuteBinaryMessage msg;
 185
 186                 msg.name                = m_cmdLine.program;
 187                 msg.params              = m_cmdLine.params;
 188                 msg.workDir             = m_cmdLine.workingDir;
 189                 msg.caseList    = m_cmdLine.caseList;
 190
 191                 sendMessage(m_socket, msg);
 192                 printf("  execution request sent.\n");
 193         }
 194
 195         // Run client loop.
 196         bool isRunning = true;
 197         while (isRunning)
 198         {
 199                 ScopedMsgPtr msg(readMessage(m_socket));
 200
 201                 switch (msg->type)
 202                 {
 203                         case MESSAGETYPE_HELLO:
 204                                 printf("  HelloMessage\n");
 205                                 break;
 206
 207                         case MESSAGETYPE_KEEPALIVE:
 208                         {
 209                                 printf("  KeepAliveMessage\n");
 210
 211                                 // Reply with keepalive.
 212                                 sendMessage(m_socket, KeepAliveMessage());
 213                                 break;
 214                         }
 215
 216                         case MESSAGETYPE_INFO:
 217                                 printf("  InfoMessage: '%s'\n", static_cast<InfoMessage*>(msg.get())->info.c_str());
 218                                 break;
 219
 220                         case MESSAGETYPE_PROCESS_STARTED:
 221                                 printf("  ProcessStartedMessage\n");
 222                                 break;
 223
 224                         case MESSAGETYPE_PROCESS_FINISHED:
 225                                 printf("  ProcessFinished: exit code = %d\n", static_cast<ProcessFinishedMessage*>(msg.get())->exitCode);
 226                                 isRunning = false;
 227                                 break;
 228
 229                         case MESSAGETYPE_PROCESS_LAUNCH_FAILED:
 230                                 printf("  ProcessLaunchFailed: '%s'\n", static_cast<ProcessLaunchFailedMessage*>(msg.get())->reason.c_str());
 231                                 isRunning = false;
 232                                 break;
 233
 234                         case MESSAGETYPE_PROCESS_LOG_DATA:
 235                         {
 236                                 ProcessLogDataMessage* logDataMsg = static_cast<ProcessLogDataMessage*>(msg.get());
 237                                 printf("  ProcessLogDataMessage: %d bytes\n", (int)logDataMsg->logData.length());
 238                                 out << logDataMsg->logData;
 239                                 break;
 240                         }
 241
 242                         default:
 243                                 XS_FAIL("Unknown message");
 244                                 break;
 245                 }
 246         }
 247
 248         // Close output file.
 249         out.close();
 250
 251         // Close connection.
 252         m_socket.shutdown();
 253         m_socket.close();
 254
 255         printf("Done!\n");
 256 }
 257
 258 string parseString (const char* str)
 259 {
 260         if (str[0] == '\'' || str[0] == '"')
 261         {
 262                 const char*                     p               = str;
 263                 char                            endChar = *p++;
 264                 std::ostringstream      o;
 265
 266                 while (*p != endChar && *p)
 267                 {
 268                         if (*p == '\\')
 269                         {
 270                                 switch (p[1])
 271                                 {
 272                                         case 0:         DE_ASSERT(DE_FALSE);    break;
 273                                         case 'n':       o << '\n';                              break;
 274                                         case 't':       o << '\t';                              break;
 275                                         default:        o << p[1];                              break;
 276                                 }
 277
 278                                 p += 2;
 279                         }
 280                         else
 281                                 o << *p++;
 282                 }
 283
 284                 return o.str();
 285         }
 286         else
 287                 return string(str);
 288 }
 289
 290 void printHelp (const char* binName)
 291 {
 292         printf("%s:\n", binName);
 293         printf("  --host=[host]          Connect to host [host]\n");
 294         printf("  --port=[name]          Use port [port]\n");
 295         printf("  --program=[program]    Test program\n");
 296         printf("  --params=[params]      Test program params\n");
 297         printf("  --workdir=[dir]        Working directory\n");
 298         printf("  --caselist=[caselist]  Test case list\n");
 299         printf("  --out=filename         Test result file\n");
 300 }
 301
 302 int runClient (int argc, const char* const* argv)
 303 {
 304         CommandLine cmdLine;
 305
 306         // Defaults.
 307         cmdLine.address.setHost("127.0.0.1");
 308         cmdLine.address.setPort(50016);
 309         cmdLine.dstFileName = "TestResults.qpa";
 310
 311         // Parse command line.
 312         for (int argNdx = 1; argNdx < argc; argNdx++)
 313         {
 314                 const char* arg = argv[argNdx];
 315
 316                 if (deStringBeginsWith(arg, "--port="))
 317                         cmdLine.address.setPort(atoi(arg+7));
 318                 else if (deStringBeginsWith(arg, "--host="))
 319                         cmdLine.address.setHost(parseString(arg+7).c_str());
 320                 else if (deStringBeginsWith(arg, "--program="))
 321                         cmdLine.program = parseString(arg+10);
 322                 else if (deStringBeginsWith(arg, "--params="))
 323                         cmdLine.params = parseString(arg+9);
 324                 else if (deStringBeginsWith(arg, "--workdir="))
 325                         cmdLine.workingDir = parseString(arg+10);
 326                 else if (deStringBeginsWith(arg, "--caselist="))
 327                         cmdLine.caseList = parseString(arg+11);
 328                 else if  (deStringBeginsWith(arg, "--out="))
 329                         cmdLine.dstFileName = parseString(arg+6);
 330                 else
 331                 {
 332                         printHelp(argv[0]);
 333                         return -1;
 334                 }
 335         }
 336
 337         // Run client.
 338         try
 339         {
 340                 Client client(cmdLine);
 341                 client.run();
 342         }
 343         catch (const std::exception& e)
 344         {
 345                 printf("%s\n", e.what());
 346                 return -1;
 347         }
 348
 349         return 0;
 350 }
 351
 352 } // xs
 353
 354 int main (int argc, const char* const* argv)
 355 {
 356         return xs::runClient(argc, argv);
 357 }