Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

AdminLogHandler and DebugHelperHandler now use generateResult for VelocyPack insted of TRI_json_t

This commit is contained in:
Michael Hackstein 2015-11-06 14:10:59 +01:00
parent 746c1a2573
commit bcc79cc1cf
2 changed files with 78 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
arangod/RestHandler/RestAdminLogHandler.cpp
View File

@ -288,11 +288,7 @@ HttpHandler::status_t RestAdminLogHandler::execute () {
return status_t(HANDLER_DONE); return status_t(HANDLER_DONE);
} }
std::vector<TRI_log_buffer_t*> clean;
TRI_vector_t clean;
TRI_InitVector(&clean, TRI_UNKNOWN_MEM_ZONE, sizeof(TRI_log_buffer_t));
for (size_t i = 0; i < TRI_LengthVector(logs); ++i) { for (size_t i = 0; i < TRI_LengthVector(logs); ++i) {
TRI_log_buffer_t* buf = (TRI_log_buffer_t*) TRI_AtVector(logs, i); TRI_log_buffer_t* buf = (TRI_log_buffer_t*) TRI_AtVector(logs, i);
@ -303,93 +299,84 @@ HttpHandler::status_t RestAdminLogHandler::execute () {
continue; continue;
} }
} }
clean.emplace_back(buf);
TRI_PushBackVector(&clean, buf);
} }
VPackBuilder result;
result.add(VPackValue(VPackValueType::Object));
size_t length = clean.size();
try {
result.add("totalAmount", VPackValue(static_cast<double>(length)));
if (offset >= length) {
TRI_json_t result; length = 0;
TRI_InitObjectJson(TRI_UNKNOWN_MEM_ZONE, &result); offset = 0;
}
// create the 4 vectors for the result parts else if (offset > 0) {
TRI_json_t* lid = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE); length -= static_cast<size_t>(offset);
TRI_json_t* level = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
TRI_json_t* timestamp = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
TRI_json_t* text = TRI_CreateArrayJson(TRI_UNKNOWN_MEM_ZONE);
TRI_Insert3ObjectJson(TRI_UNKNOWN_MEM_ZONE, &result, "totalAmount", TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) TRI_LengthVector(&clean)));
size_t length = TRI_LengthVector(&clean);
if (offset >= length) {
length = 0;
offset = 0;
}
else if (offset > 0) {
length -= static_cast<size_t>(offset);
}
// restrict to at most <size> elements
if (length > size) {
length = static_cast<size_t>(size);
}
qsort(((char*) TRI_BeginVector(&clean)) + offset * sizeof(TRI_log_buffer_t),
length,
sizeof(TRI_log_buffer_t),
(sortAscending ? LidCompareAsc : LidCompareDesc));
for (size_t i = 0; i < length; ++i) {
TRI_log_buffer_t* buf = (TRI_log_buffer_t*) TRI_AtVector(&clean, (size_t) (offset + i));
uint32_t l = 0;
switch (buf->_level) {
case TRI_LOG_LEVEL_FATAL: l = 0; break;
case TRI_LOG_LEVEL_ERROR: l = 1; break;
case TRI_LOG_LEVEL_WARNING: l = 2; break;
case TRI_LOG_LEVEL_INFO: l = 3; break;
case TRI_LOG_LEVEL_DEBUG: l = 4; break;
case TRI_LOG_LEVEL_TRACE: l = 5; break;
} }
// put the data into the individual vectors // restrict to at most <size> elements
if (lid != nullptr) { if (length > size) {
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, lid, TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) buf->_lid)); length = static_cast<size_t>(size);
} }
if (level != nullptr) { std::sort(clean.begin() + offset, clean.begin() + offset + length, (sortAscending ? LidCompareAsc : LidCompareDesc));
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, level, TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) l));
// For now we build the arrays one ofter the other
// first lid
result.add("lid", VPackValue(VPackValueType::Array));
for (size_t i = 0; i < length; ++i) {
TRI_log_buffer_t* buf = clean.at(i + static_cast<size_t>(offset));
result.add(VPackValue(buf->_lid));
} }
result.close();
if (timestamp != nullptr) { // second level
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, timestamp, TRI_CreateNumberJson(TRI_UNKNOWN_MEM_ZONE, (double) buf->_timestamp)); result.add("level", VPackValue(VPackValueType::Array));
for (size_t i = 0; i < length; ++i) {
TRI_log_buffer_t* buf = clean.at(i + static_cast<size_t>(offset));
uint32_t l = 0;
switch (buf->_level) {
case TRI_LOG_LEVEL_FATAL: l = 0; break;
case TRI_LOG_LEVEL_ERROR: l = 1; break;
case TRI_LOG_LEVEL_WARNING: l = 2; break;
case TRI_LOG_LEVEL_INFO: l = 3; break;
case TRI_LOG_LEVEL_DEBUG: l = 4; break;
case TRI_LOG_LEVEL_TRACE: l = 5; break;
}
result.add(VPackValue(l));
} }
result.close();
if (text != nullptr) { // third timestamp
TRI_PushBack3ArrayJson(TRI_UNKNOWN_MEM_ZONE, text, TRI_CreateStringCopyJson(TRI_UNKNOWN_MEM_ZONE, buf->_text, strlen(buf->_text))); result.add("timestamp", VPackValue(VPackValueType::Array));
for (size_t i = 0; i < length; ++i) {
TRI_log_buffer_t* buf = clean.at(i + static_cast<size_t>(offset));
result.add(VPackValue(static_cast<double>(buf->_timestamp)));
} }
} result.close();
TRI_FreeBufferLogging(logs); // forth text
TRI_DestroyVector(&clean); result.add("text", VPackValue(VPackValueType::Array));
for (size_t i = 0; i < length; ++i) {
TRI_log_buffer_t* buf = clean.at(i + static_cast<size_t>(offset));
result.add(VPackValue(buf->_text));
}
result.close();
// now put the 4 vectors into the result result.close(); // Close the result object
if (lid != nullptr) {
TRI_Insert3ObjectJson(TRI_UNKNOWN_MEM_ZONE, &result, "lid", lid);
}
if (level != nullptr) {
TRI_Insert3ObjectJson(TRI_UNKNOWN_MEM_ZONE, &result, "level", level);
}
if (timestamp != nullptr) {
TRI_Insert3ObjectJson(TRI_UNKNOWN_MEM_ZONE, &result, "timestamp", timestamp);
}
if (text != nullptr) {
TRI_Insert3ObjectJson(TRI_UNKNOWN_MEM_ZONE, &result, "text", text);
}
generateResult(&result); TRI_FreeBufferLogging(logs);
TRI_DestroyJson(TRI_UNKNOWN_MEM_ZONE, &result); VPackSlice slice(result.start());
generateResult(slice);
}
catch (...) {
// Not Enough memory to build everything up
// Has been ignored thus far
// So ignore again
}
return status_t(HANDLER_DONE); return status_t(HANDLER_DONE);
} }

37
arangod/RestHandler/RestDebugHelperHandler.cpp
View File

@ -72,20 +72,8 @@ bool RestDebugHelperHandler::isDirect () const {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
HttpHandler::status_t RestDebugHelperHandler::execute () { HttpHandler::status_t RestDebugHelperHandler::execute () {
TRI_json_t result;
RequestStatisticsAgentSetIgnore(this); RequestStatisticsAgentSetIgnore(this);
TRI_InitObjectJson(TRI_CORE_MEM_ZONE, &result, 3);
TRI_json_t server;
TRI_InitStringJson(&server, TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, "arango"), strlen("arango"));
TRI_Insert2ObjectJson(TRI_CORE_MEM_ZONE, &result, "server", &server);
TRI_json_t version;
TRI_InitStringJson(&version, TRI_DuplicateStringZ(TRI_CORE_MEM_ZONE, TRI_VERSION), strlen(TRI_VERSION));
TRI_Insert2ObjectJson(TRI_CORE_MEM_ZONE, &result, "version", &version);
bool found; bool found;
char const* sleepStr = _request->value("sleep", found); char const* sleepStr = _request->value("sleep", found);
auto s = static_cast<unsigned long>(StringUtils::doubleDecimal(sleepStr) * 1000.0 * 1000.0); auto s = static_cast<unsigned long>(StringUtils::doubleDecimal(sleepStr) * 1000.0 * 1000.0);
@ -105,17 +93,20 @@ HttpHandler::status_t RestDebugHelperHandler::execute () {
_dispatcherThread->unblock(); _dispatcherThread->unblock();
} }
TRI_json_t sleepNumber; try {
TRI_InitNumberJson(&sleepNumber, s / 1000000.0); VPackBuilder result;
TRI_Insert2ObjectJson(TRI_CORE_MEM_ZONE, &result, "sleep", &sleepNumber); result.add(VPackValue(VPackValueType::Object));
result.add("server", VPackValue("arango"));
TRI_json_t blockFlag; result.add("version", VPackValue(TRI_VERSION));
TRI_InitBooleanJson(&blockFlag, block); result.add("sleep", VPackValue(s / 1000000.0));
TRI_Insert2ObjectJson(TRI_CORE_MEM_ZONE, &result, "block", &blockFlag); result.add("block", VPackValue(block));
result.close();
generateResult(&result); VPackSlice slice(result.start());
TRI_DestroyJson(TRI_CORE_MEM_ZONE, &result); generateResult(slice);
}
catch (...) {
// Ignore the error
}
return status_t(HANDLER_DONE); return status_t(HANDLER_DONE);
} }