Files
cocos4/native/cocos/base/LogRemote.cpp
T
江战 19fe1db252 LogRemote upgrade configuration protocol (#12833)
* update config

* Update LogRemote.cpp
2022-09-22 14:29:05 +08:00

338 lines
11 KiB
C++

/****************************************************************************
Copyright (c) 2022 Xiamen Yaji Software Co., Ltd.
http://www.cocos.com
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated engine source code (the "Software"), a limited,
worldwide, royalty-free, non-assignable, revocable and non-exclusive license
to use Cocos Creator solely to develop games on your target platforms. You shall
not use Cocos Creator software for developing other software or tools that's
used for developing games. You are not granted to publish, distribute,
sublicense, and/or sell copies of Cocos Creator.
The software or tools in this License Agreement are licensed, not sold.
Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "base/Log.h"
#if CC_REMOTE_LOG
#include <chrono>
#include <sstream>
#include <string_view>
#include "platform/FileUtils.h"
#include "rapidjson/document.h"
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <Windows.h>
#include <winsock2.h>
#include <cstdio>
#pragma comment(lib, "ws2_32.lib")
#else
#include <arpa/inet.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#endif
namespace {
// #define AUTO_TEST_CONFIG_FILE "auto-test-config.json" // v1
#define AUTO_TEST_CONFIG_FILE "testConfig.json" // v2
#define OLD_ATC_KEY_CONFIG "ServerConfig"
#define OLD_ATC_KEY_IP "IP"
#define OLD_ATC_KEY_PORT "PORT"
#define OLD_ATC_KEY_PLANID "planId"
#define OLD_ATC_KEY_FLAGID "flagId"
#define ATC_KEY_CONFIG "localServer"
#define ATC_KEY_IP "ip"
#define ATC_KEY_PORT "port"
#define ATC_KEY_JOBID "jobId"
#define ATC_KEY_PLATFORMS "platforms"
#define ATC_KEY_PLATFORM_INDEX "platformIndex"
enum class UdpLogClientState {
UNINITIALIZED,
INITIALIZED,
CONFIGURED,
OK,
DONE, // FAILED
};
/**
* Parse auto-test-config.json to get ServerConfig.IP & ServerConfig.PORT
* Logs will be formated with 5 fields
* 1. testId
* 2. clientId
* 3. bootId, the boot timestamp
* 4. milliseconds since boot
* 5. log content
*
* These parts are joined with '\n'.
*
* The log text is sent to the server via UDP. Due to the nature of the UDP protocol,
* there may be packet loss/missequencing issues.
*/
class UdpLogClient {
public:
UdpLogClient() {
init();
tryParseConfig();
}
~UdpLogClient() {
deinit();
}
void sendFullLog(const std::string_view &msg) {
if (_status == UdpLogClientState::DONE) {
return;
}
auto timeNow = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count();
std::stringstream ss;
ss << _testID << std::endl
<< _clientID << std::endl
<< _bootID << std::endl
<< (timeNow - _bootID) << std::endl
<< msg;
sendLog(ss.str());
}
private:
void init() {
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
WSAData wsa;
if (WSAStartup(MAKEWORD(1, 2), &wsa) != 0) {
printf("WSAStartup failed, code: %d\n", WSAGetLastError());
_status = UdpLogClientState::DONE;
return;
}
#endif
_status = UdpLogClientState::INITIALIZED;
}
void deinit() {
if (_status == UdpLogClientState::OK) {
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
closesocket(_sock);
WSACleanup();
#else
close(_sock);
#endif
}
}
void tryParseConfig() {
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
if (_status != UdpLogClientState::INITIALIZED) {
return;
}
#endif
auto *fu = cc::FileUtils::getInstance();
if (!fu) {
// engine is not ready, retry later
return;
}
if (!fu->isFileExist(AUTO_TEST_CONFIG_FILE)) {
_status = UdpLogClientState::DONE;
return;
}
auto content = fu->getStringFromFile(AUTO_TEST_CONFIG_FILE);
rapidjson::Document doc;
doc.Parse(content.c_str(), content.length());
if (doc.HasParseError()) {
auto code = doc.GetParseError();
_status = UdpLogClientState::DONE;
return;
}
if (doc.HasMember(OLD_ATC_KEY_CONFIG)) {
// parse clientID & testID
if (doc.HasMember(OLD_ATC_KEY_FLAGID)) {
_clientID = doc[OLD_ATC_KEY_FLAGID].GetString();
} else {
_clientID = "flagId is not set!";
}
if (doc.HasMember(OLD_ATC_KEY_PLANID)) {
_testID = doc[OLD_ATC_KEY_PLANID].GetString();
} else {
_testID = "planId is not set!";
}
// parse ip & port
rapidjson::Value &cfg = doc[OLD_ATC_KEY_CONFIG];
if (!cfg.HasMember(OLD_ATC_KEY_IP) || !cfg.HasMember(OLD_ATC_KEY_PORT)) {
_status = UdpLogClientState::DONE;
return;
}
const char *remoteIp = cfg[OLD_ATC_KEY_IP].GetString();
// The `PORT` property is used by other service and the next port is for log collection.
int remotePort = cfg[OLD_ATC_KEY_PORT].GetInt() + 1;
setServerAddr(remoteIp, remotePort);
} else if (doc.HasMember(ATC_KEY_CONFIG)) {
if (doc.HasMember(ATC_KEY_JOBID)) {
_testID = doc[ATC_KEY_JOBID].GetString();
} else {
_testID = "jobId is not set!";
}
if (doc.HasMember(ATC_KEY_PLATFORMS)) {
rapidjson::Value &platforms = doc[ATC_KEY_PLATFORMS];
if (!platforms.IsArray() || platforms.Size() < 1) {
_clientID = "array platforms is empty";
} else {
rapidjson::Value &plt = platforms[0];
if (!plt.HasMember(ATC_KEY_PLATFORM_INDEX)) {
_clientID = "platforms[0] not key platformIndex";
} else {
rapidjson::Value &index = plt[ATC_KEY_PLATFORM_INDEX];
_clientID = index.IsInt() ? std::to_string(index.GetInt()) : index.GetString();
}
}
} else {
_clientID = "platforms not set!";
}
// parse ip & port
rapidjson::Value &cfg = doc[ATC_KEY_CONFIG];
if (!cfg.HasMember(ATC_KEY_IP) || !cfg.HasMember(ATC_KEY_PORT)) {
_status = UdpLogClientState::DONE;
return;
}
const char *remoteIp = cfg[ATC_KEY_IP].GetString();
// The `PORT` property is used by other service and the next port is for log collection.
int remotePort = cfg[ATC_KEY_PORT].GetInt() + 1;
setServerAddr(remoteIp, remotePort);
} else {
_status = UdpLogClientState::DONE;
return;
}
_bootID = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::system_clock::now().time_since_epoch())
.count();
_status = UdpLogClientState::CONFIGURED;
}
void setServerAddr(const std::string_view &addr, int port) {
memset(&_serverAddr, 0, sizeof(_serverAddr));
_serverAddr.sin_family = AF_INET;
_serverAddr.sin_addr.s_addr = inet_addr(addr.data());
_serverAddr.sin_port = htons(port);
}
static auto getErrorCode() {
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
return WSAGetLastError();
#else
return errno;
#endif
}
void ensureInitSocket() {
if (_status == UdpLogClientState::INITIALIZED) {
tryParseConfig();
}
if (_status != UdpLogClientState::CONFIGURED) {
return;
}
memset(&_localAddr, 0, sizeof(_localAddr));
_localAddr.sin_family = AF_INET;
_localAddr.sin_addr.s_addr = INADDR_ANY;
_localAddr.sin_port = 0; // bind random port
if ((_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
auto errorCode = getErrorCode();
_status = UdpLogClientState::DONE;
printf("create socket failed, code: %d\n", errorCode);
return;
}
if (bind(_sock, reinterpret_cast<sockaddr *>(&_localAddr), sizeof(_localAddr))) {
_status = UdpLogClientState::DONE;
auto errorCode = getErrorCode();
printf("bind socket failed, code: %d\n", errorCode);
return;
}
if (connect(_sock, reinterpret_cast<sockaddr *>(&_serverAddr), sizeof(_serverAddr))) {
auto errorCode = getErrorCode();
printf("connect socket failed, code: %d\n", errorCode);
_status = UdpLogClientState::DONE;
return;
}
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
u_long mode = 1;
if (ioctlsocket(_sock, FIONBIO, &mode)) {
auto errorCode = getErrorCode();
printf("set nonblock failed, code: %d\n", errorCode);
// continue
}
#else
int flags = fcntl(_sock, F_GETFL);
if (fcntl(_sock, F_SETFL, flags | O_NONBLOCK)) {
auto errorCode = getErrorCode();
printf("set nonblock failed, code: %d\n", errorCode);
// continue
}
#endif
_status = UdpLogClientState::OK;
}
void sendLog(const std::string_view &msg) {
ensureInitSocket();
if (_status == UdpLogClientState::OK) {
send(_sock, msg.data(), msg.size(), 0);
}
}
#if CC_PLATFORM == CC_PLATFORM_WINDOWS
SOCKET _sock{INVALID_SOCKET};
#else
int _sock{-1};
#endif
sockaddr_in _serverAddr;
sockaddr_in _localAddr;
UdpLogClientState _status{UdpLogClientState::UNINITIALIZED};
std::string _testID;
std::string _clientID;
uint64_t _bootID{0};
};
void sendLogThroughUDP(const std::string_view &msg) {
static UdpLogClient remote;
remote.sendFullLog(msg);
}
} // namespace
#endif
namespace cc {
void Log::logRemote(const char *msg) {
#if CC_REMOTE_LOG
sendLogThroughUDP(msg);
#endif
}
} // namespace cc