MongodbObject * GameCore::CreateSubObject(const String &objectName, MongodbObject *dbObject, bool needFinished)
{
MongodbObject *subObject = new MongodbObject();
if(dbObject)
{
bool ret = dbObject->GetSubObject(subObject, objectName, needFinished);
if(ret)
{
return subObject;
}
}
subObject->SetObjectName(objectName);
return subObject;
}
bool MongodbClient::SaveObject(MongodbObject *object)
{
int32 status = MONGO_ERROR;
if(IsConnected())
{
MongodbObject *foundObject = FindObjectByKey(object->GetObjectName());
if(foundObject)
{
status = mongo_update(clientData->connection, namespaceName.c_str(), (bson *)foundObject->InternalObject(), (bson *)object->InternalObject(), 0, NULL);
if(MONGO_OK != status)
{
LogError(String("SaveObject, update"), clientData->connection->err);
}
SafeRelease(foundObject);
}
else
{
status = mongo_insert(clientData->connection, namespaceName.c_str(), (bson *)object->InternalObject(), NULL);
if(MONGO_OK != status)
{
LogError(String("SaveObject, insert"), clientData->connection->err);
}
}
}
return (MONGO_OK == status);
}
bool MongodbClient::GetBinary(const String &key, uint8 *outData, int32 dataSize)
{
bool found = false;
MongodbObject *object = FindObjectByKey(key);
if(object)
{
found = object->GetData(String("Data"), outData, dataSize);
SafeRelease(object);
}
else
{
Logger::Error("[MongodbClient] Can't find binary to get data.");
}
return found;
}
int32 MongodbClient::GetBinarySize(const String &key)
{
int32 retSize = 0;
MongodbObject *object = FindObjectByKey(key);
if(object)
{
retSize = object->GetInt32(String("DataSize"));
SafeRelease(object);
}
else
{
Logger::Error("[MongodbClient] Can't find binary to get size.");
}
return retSize;
}
bool MongodbClient::FindObjectByKey(const String &key, MongodbObject * foundObject)
{
DVASSERT(foundObject);
MongodbObject *query = new MongodbObject();
DVASSERT(query);
query->SetObjectName(key);
query->Finish();
int32 status = mongo_find_one(clientData->connection, namespaceName.c_str(), (bson *)query->InternalObject(), 0, (bson *)foundObject->InternalObject());
if(MONGO_OK != status)
{
return false;
}
SafeRelease(query);
return true;
}
bool GameCore::ConnectToDB()
{
if(dbClient)
return true;
dbClient = MongodbClient::Create(DATABASE_IP, DATAPASE_PORT);
if(dbClient)
{
dbClient->SetDatabaseName(DATABASE_NAME);
dbClient->SetCollectionName(DATABASE_COLLECTION);
MongodbObject *globalIdObject = dbClient->FindObjectByKey("GlobalTestId");
if(globalIdObject)
currentRunId = globalIdObject->GetInt32("LastTestId") + 1;
MongodbObject * newGlobalIdObject = new MongodbObject();
newGlobalIdObject->SetObjectName("GlobalTestId");
newGlobalIdObject->AddInt32("LastTestId", currentRunId);
newGlobalIdObject->Finish();
dbClient->SaveObject(newGlobalIdObject, globalIdObject);
SafeRelease(newGlobalIdObject);
SafeRelease(globalIdObject);
}
else
{
Logger::Debug("Can't connect to DB");
}
return (dbClient != NULL);
}
bool MongodbClient::SaveBinary(const String &key, uint8 *data, int32 dataSize)
{
int32 status = MONGO_ERROR;
if(IsConnected())
{
MongodbObject * binary = new MongodbObject();
DVASSERT(binary);
binary->SetObjectName(key);
binary->AddInt32(String("DataSize").c_str(), dataSize);
binary->AddData(String("Data").c_str(), data, dataSize);
binary->Finish();
MongodbObject *foundObject = FindObjectByKey(key);
if(foundObject)
{
status = mongo_update(clientData->connection, namespaceName.c_str(), (bson *)foundObject->InternalObject(), (bson *)binary->InternalObject(), 0, NULL);
if(MONGO_OK != status)
{
LogError(String("SaveBinary, update"), clientData->connection->err);
}
SafeRelease(foundObject);
}
else
{
status = mongo_insert(clientData->connection, namespaceName.c_str(), (bson *)binary->InternalObject(), NULL);
if(MONGO_OK != status)
{
LogError(String("SaveBinary, insert"), clientData->connection->err);
}
}
SafeRelease(binary);
}
return (MONGO_OK == status);
}
MongodbObject * GameCore::CreateTestDataObject(const String &testTimeString, const String &runTime, TestData *testData)
{
MongodbObject *logObject = new MongodbObject();
if(logObject)
{
logObject->SetObjectName(testTimeString);
logObject->AddString(String("Owner"), TEST_OWNER);
logObject->AddString(String("RunTime"), runTime);
logObject->AddInt32(String("DeviceFamily"), (int32)Core::Instance()->GetDeviceFamily());
logObject->AddInt64(String("TotalTime"), testData->totalTime);
logObject->AddInt64(String("MinTime"), testData->minTime);
logObject->AddInt64(String("MaxTime"), testData->maxTime);
logObject->AddInt32(String("MaxTimeIndex"), testData->maxTimeIndex);
logObject->AddInt64(String("StartTime"), testData->startTime);
logObject->AddInt64(String("EndTime"), testData->endTime);
logObject->AddInt32(String("RunCount"), testData->runCount);
if(testData->runCount)
{
logObject->AddDouble(String("Average"), (double)testData->totalTime / (double)testData->runCount);
}
else
{
logObject->AddDouble(String("Average"), (double)0.0f);
}
logObject->Finish();
}
return logObject;
}
void GameCore::FlushTestResults()
{
if(!dbClient) return;
MongodbObject *oldPlatformObject = dbClient->FindObjectByKey(PLATFORM_NAME);
MongodbObject *newPlatformObject = new MongodbObject();
int64 globalIndex = 0;
if(oldPlatformObject)
{
globalIndex = oldPlatformObject->GetInt64(String("globalIndex"));
++globalIndex;
}
if(newPlatformObject)
{
newPlatformObject->SetObjectName(PLATFORM_NAME);
newPlatformObject->AddInt64(String("globalIndex"), globalIndex);
String testTimeString = Format("%016d", globalIndex);
time_t logStartTime = time(0);
tm* utcTime = localtime(&logStartTime);
String runTime = Format("%04d.%02d.%02d:%02d:%02d:%02d",
utcTime->tm_year + 1900, utcTime->tm_mon + 1, utcTime->tm_mday,
utcTime->tm_hour, utcTime->tm_min, utcTime->tm_sec);
for(int32 iScr = 0; iScr < screens.size(); ++iScr)
{
int32 count = screens[iScr]->GetTestCount();
#if defined (SINGLE_MODE)
if(screens[iScr]->GetName() == SINGLE_TEST_NAME)
#endif //#if defined (SINGLE_MODE)
{
MongodbObject *oldScreenObject = CreateSubObject(screens[iScr]->GetName(), oldPlatformObject, true);
MongodbObject *newScreenObject = new MongodbObject();
if(newScreenObject)
{
newScreenObject->SetObjectName(screens[iScr]->GetName());
for(int32 iTest = 0; iTest < count; ++iTest)
{
TestData *td = screens[iScr]->GetTestData(iTest);
MongodbObject *testObject = CreateSubObject(td->name, oldScreenObject, false);
if(testObject)
{
MongodbObject *testDataObject = CreateTestDataObject(testTimeString, runTime, td);
if(testDataObject)
{
testObject->AddObject(testTimeString, testDataObject);
testObject->Finish();
SafeRelease(testDataObject);
}
newScreenObject->AddObject(td->name, testObject);
SafeRelease(testObject);
}
}
newScreenObject->Finish();
newPlatformObject->AddObject(screens[iScr]->GetName(), newScreenObject);
SafeRelease(newScreenObject);
}
SafeRelease(oldScreenObject);
}
}
newPlatformObject->Finish();
dbClient->SaveObject(newPlatformObject, oldPlatformObject);
SafeRelease(newPlatformObject);
}
SafeRelease(oldPlatformObject);
}
bool GameCore::FlushToDB(const String & levelName, const Map<String, String> &results, const String &imagePath)
{
if(!dbClient)
return false;
Logger::Debug("Sending results to DB...");
MongodbObject *testResultObject = new MongodbObject();
if(testResultObject)
{
testResultObject->SetObjectName(levelName);
Map<String, String>::const_iterator it = results.begin();
for(; it != results.end(); it++)
{
testResultObject->AddString((*it).first, (*it).second);
}
File * imageFile = File::Create(imagePath, File::READ | File::OPEN);
if(imageFile)
{
uint32 fileSize = imageFile->GetSize();
uint8 * data = new uint8[fileSize];
imageFile->Read(data, fileSize);
testResultObject->AddData("ResultImagePNG", data, fileSize);
SafeDelete(data);
SafeRelease(imageFile);
}
else
{
Logger::Debug("Can't read result level sprite!");
}
testResultObject->Finish();
MongodbObject * currentRunObject = dbClient->FindObjectByKey(Format("%d", currentRunId));
MongodbObject * newRunObject = new MongodbObject();
if(newRunObject)
{
if(currentRunObject)
{
newRunObject->Copy(currentRunObject);
}
else
{
newRunObject->SetObjectName(Format("%d", currentRunId));
newRunObject->AddString("DeviceDescription", DeviceInfo::Instance()->GetDeviceDescription());
}
newRunObject->AddObject(levelName, testResultObject);
newRunObject->Finish();
dbClient->SaveObject(newRunObject, currentRunObject);
SafeRelease(newRunObject);
}
else
{
Logger::Debug("Can't create test result object in DB");
return false;
}
SafeRelease(currentRunObject);
SafeRelease(testResultObject);
}
else
{
Logger::Debug("Can't create tests results object");
return false;
}
Logger::Debug("Results successful sent to DB");
return true;
}
void MongodbClient::WriteData(MongodbObject* mongoObj, const String & key, VariantType *value)
{
if(mongoObj && value)
{
if(key == "_id") return; // ignore _id
//TODO: bool, uint32 and WideString have no corresponding types in mongoDB
switch (value->GetType())
{
case VariantType::TYPE_BOOLEAN:
{
mongoObj->AddInt32(key, value->AsBool());
}
break;
case VariantType::TYPE_INT32:
{
mongoObj->AddInt32(key, value->AsInt32());
}
break;
case VariantType::TYPE_FLOAT:
{
mongoObj->AddDouble(key, value->AsFloat());
}
break;
case VariantType::TYPE_STRING:
{
mongoObj->AddString(key, value->AsString());
}
break;
case VariantType::TYPE_WIDE_STRING:
{
mongoObj->AddString(key, WStringToString(value->AsWideString()));
}
break;
case VariantType::TYPE_BYTE_ARRAY:
{
mongoObj->AddData(key, const_cast<uint8*>(value->AsByteArray()), value->AsByteArraySize());
}
break;
case VariantType::TYPE_UINT32:
{
mongoObj->AddInt32(key, value->AsUInt32());
}
break;
case VariantType::TYPE_KEYED_ARCHIVE:
{
MongodbObject* subObject = new MongodbObject();
KeyedArchive* subArchive = value->AsKeyedArchive();
KeyedArchiveToDBObject(subArchive, subObject);
subObject->SetObjectName(key);
subObject->Finish();
mongoObj->AddObject(key, subObject);
SafeRelease(subObject);
}
break;
default:
{
DVASSERT(false);
Logger::Error("[MongodbUpdateObject::WriteData] Not implemented type: %d", value->GetType());
}
break;
}
}
}
