LRESULT Cdispatcher_uiDlg::OnReadStats(WPARAM wparam, LPARAM lParam) {
char *buf = (char*)wparam;
Document d;
if (d.Parse(buf).HasParseError()) {
int unicodeLen = MultiByteToWideChar(CP_ACP, 0, buf, -1, 0, 0);
wchar_t *wc = new wchar_t[unicodeLen+1];
memset(wc, 0, (unicodeLen + 1)*sizeof(wchar_t));
MultiByteToWideChar(CP_ACP, 0, buf, -1, wc, unicodeLen);
m_static_msg.SetWindowText(wc);
delete[]wc;
}
else {
//read/stats
uint64_t count_service = 0;
uint64_t count_dispatch = 0;
for (Value::ConstMemberIterator iter = d.MemberBegin(); iter != d.MemberEnd(); ++iter) {
const char * app = iter->name.GetString();
count_service += iter->value["service"].GetUint64();
count_dispatch += iter->value["dispatch"].GetUint64();
}
wchar_t tmp[1024];
swprintf_s(tmp, L"%lld", count_dispatch);
m_dispatch_count.SetWindowTextW(tmp);
swprintf_s(tmp, L"%lld", count_service);
m_service_count.SetWindowTextW(tmp);
}
return 0;
}
/**
* Merge one set of options into this one.
* All settings in the input take precedence over anything currently stored.
* @param json_string The serialised JSON string to merge from.
* @return true iff successfully merged.
*/
bool Options::Merge(const char *json_string) {
if (json_string) {
Document d;
d.Parse<0>(json_string);
if (!d.HasParseError() && d.IsObject()) {
//Loop through each family
for (Value::ConstMemberIterator it = d.MemberBegin();
it != d.MemberEnd(); it++)
{
//Do we have a family of options? (e.g. an object)
if (it->value.IsObject()) {
SetFamily(it->name.GetString());
//Loop through each option
for (Value::ConstMemberIterator optit = it->value.MemberBegin();
optit != it->value.MemberEnd(); optit++)
{
const char *optkey = optit->name.GetString();
switch (optit->value.GetType()) {
case kFalseType: case kTrueType:
Set(optkey, optit->value.GetBool());
case kNumberType:
if (optit->value.IsInt()) {
Set(optkey, optit->value.GetInt());
} else if (optit->value.IsNumber()) {
Set(optkey, optit->value.GetDouble());
} else if (optit->value.IsBool()) {
Set(optkey, optit->value.GetBool());
}
break;
case kStringType:
Set(optkey, optit->value.GetString());
break;
case kNullType: //Ignore
break;
default:
Log(LOG_WARNING, "Ignoring unknown option %s of type %d",
optkey, optit->value.GetType());
}
}
} else {
Log(LOG_WARNING, "Ignoring unknown family %s of type %d",
it->name.GetString(), it->value.GetType());
}
}
return true;
}
}
return false;
}
std::map<std::string, std::string> ConfigParser::GetConfigMap()
{
std::map<std::string, std::string> configMap;
stringstream err;
FILE* fp = fopen(configPath.c_str(), "rb");
if(!fp){
err << "Could not open file " << configPath << "!";
errors.push_back(err.str());
return configMap;
}
char readBuffer[CONFIGPARSER_BUF_SIZE] = {};
FileReadStream configStream(fp, readBuffer, sizeof(readBuffer));
Document d;
d.ParseStream(configStream);
if(!d.IsObject()){
return configMap;
}
for(Value::MemberIterator it = d.MemberBegin(); it != d.MemberEnd(); ++it){
if ( !it->name.IsString() )
{
LOG_RELEASE("Warning: JSON key value is not a string.");
continue;
}
if(strcmp(it->name.GetString(),"Port") == 0){
configMap[it->name.GetString()] = "";
}
else if(strcmp(it->name.GetString(),"Roster") == 0){
configMap[it->name.GetString()] = "";
}
else{
// Ignore non-string
if ( it->value.IsString() )
{
configMap[it->name.GetString()] = it->value.GetString();
}
}
}
fclose(fp);
return configMap;
}
Sprites parseSprite(const std::string& image, const std::string& json) {
using namespace rapidjson;
Sprites sprites;
// Parse the sprite image.
const util::Image raster(image);
if (!raster) {
Log::Warning(Event::Sprite, "Could not parse sprite image");
return sprites;
}
Document doc;
doc.Parse<0>(json.c_str());
if (doc.HasParseError()) {
Log::Warning(Event::Sprite, std::string{ "Failed to parse JSON: " } + doc.GetParseError() +
" at offset " + std::to_string(doc.GetErrorOffset()));
return sprites;
} else if (!doc.IsObject()) {
Log::Warning(Event::Sprite, "Sprite JSON root must be an object");
return sprites;
} else {
for (Value::ConstMemberIterator itr = doc.MemberBegin(); itr != doc.MemberEnd(); ++itr) {
const std::string name = { itr->name.GetString(), itr->name.GetStringLength() };
const Value& value = itr->value;
if (value.IsObject()) {
const uint16_t x = getUInt16(value, "x", 0);
const uint16_t y = getUInt16(value, "y", 0);
const uint16_t width = getUInt16(value, "width", 0);
const uint16_t height = getUInt16(value, "height", 0);
const double pixelRatio = getDouble(value, "pixelRatio", 1);
const bool sdf = getBoolean(value, "sdf", false);
auto sprite = createSpriteImage(raster, x, y, width, height, pixelRatio, sdf);
if (sprite) {
sprites.emplace(name, sprite);
}
}
}
}
return sprites;
}
int main(int, char*[]) {
////////////////////////////////////////////////////////////////////////////
// 1. Parse a JSON text string to a document.
const char json[] = " { \"hello\" : \"world\", \"t\" : true , \"f\" : false, \"n\": null, \"i\":123, \"pi\": 3.1416, \"a\":[1, 2, 3, 4] } ";
printf("Original JSON:\n %s\n", json);
Document document; // Default template parameter uses UTF8 and MemoryPoolAllocator.
#if 0
// "normal" parsing, decode strings to new buffers. Can use other input stream via ParseStream().
if (document.Parse(json).HasParseError())
return 1;
#else
// In-situ parsing, decode strings directly in the source string. Source must be string.
char buffer[sizeof(json)];
memcpy(buffer, json, sizeof(json));
if (document.ParseInsitu(buffer).HasParseError())
return 1;
#endif
printf("\nParsing to document succeeded.\n");
////////////////////////////////////////////////////////////////////////////
// 2. Access values in document.
printf("\nAccess values in document:\n");
assert(document.IsObject()); // Document is a JSON value represents the root of DOM. Root can be either an object or array.
assert(document.HasMember("hello"));
assert(document["hello"].IsString());
printf("hello = %s\n", document["hello"].GetString());
// Since version 0.2, you can use single lookup to check the existing of member and its value:
Value::MemberIterator hello = document.FindMember("hello");
assert(hello != document.MemberEnd());
assert(hello->value.IsString());
assert(strcmp("world", hello->value.GetString()) == 0);
(void)hello;
assert(document["t"].IsBool()); // JSON true/false are bool. Can also uses more specific function IsTrue().
printf("t = %s\n", document["t"].GetBool() ? "true" : "false");
assert(document["f"].IsBool());
printf("f = %s\n", document["f"].GetBool() ? "true" : "false");
printf("n = %s\n", document["n"].IsNull() ? "null" : "?");
assert(document["i"].IsNumber()); // Number is a JSON type, but C++ needs more specific type.
assert(document["i"].IsInt()); // In this case, IsUint()/IsInt64()/IsUInt64() also return true.
printf("i = %d\n", document["i"].GetInt()); // Alternative (int)document["i"]
assert(document["pi"].IsNumber());
assert(document["pi"].IsDouble());
printf("pi = %g\n", document["pi"].GetDouble());
{
const Value& a = document["a"]; // Using a reference for consecutive access is handy and faster.
assert(a.IsArray());
for (SizeType i = 0; i < a.Size(); i++) // rapidjson uses SizeType instead of size_t.
printf("a[%d] = %d\n", i, a[i].GetInt());
int y = a[0].GetInt();
(void)y;
// Iterating array with iterators
printf("a = ");
for (Value::ConstValueIterator itr = a.Begin(); itr != a.End(); ++itr)
printf("%d ", itr->GetInt());
printf("\n");
}
// Iterating object members
static const char* kTypeNames[] = { "Null", "False", "True", "Object", "Array", "String", "Number" };
for (Value::ConstMemberIterator itr = document.MemberBegin(); itr != document.MemberEnd(); ++itr)
printf("Type of member %s is %s\n", itr->name.GetString(), kTypeNames[itr->value.GetType()]);
////////////////////////////////////////////////////////////////////////////
// 3. Modify values in document.
// Change i to a bigger number
{
uint64_t f20 = 1; // compute factorial of 20
for (uint64_t j = 1; j <= 20; j++)
f20 *= j;
document["i"] = f20; // Alternate form: document["i"].SetUint64(f20)
assert(!document["i"].IsInt()); // No longer can be cast as int or uint.
}
// Adding values to array.
{
Value& a = document["a"]; // This time we uses non-const reference.
Document::AllocatorType& allocator = document.GetAllocator();
for (int i = 5; i <= 10; i++)
a.PushBack(i, allocator); // May look a bit strange, allocator is needed for potentially realloc. We normally uses the document's.
// Fluent API
a.PushBack("Lua", allocator).PushBack("Mio", allocator);
}
// Making string values.
// This version of SetString() just store the pointer to the string.
// So it is for literal and string that exists within value's life-cycle.
{
document["hello"] = "rapidjson"; // This will invoke strlen()
// Faster version:
// document["hello"].SetString("rapidjson", 9);
}
// This version of SetString() needs an allocator, which means it will allocate a new buffer and copy the the string into the buffer.
Value author;
{
char buffer[10];
int len = sprintf(buffer, "%s %s", "Milo", "Yip"); // synthetic example of dynamically created string.
author.SetString(buffer, static_cast<size_t>(len), document.GetAllocator());
// Shorter but slower version:
// document["hello"].SetString(buffer, document.GetAllocator());
// Constructor version:
// Value author(buffer, len, document.GetAllocator());
// Value author(buffer, document.GetAllocator());
memset(buffer, 0, sizeof(buffer)); // For demonstration purpose.
}
// Variable 'buffer' is unusable now but 'author' has already made a copy.
document.AddMember("author", author, document.GetAllocator());
assert(author.IsNull()); // Move semantic for assignment. After this variable is assigned as a member, the variable becomes null.
////////////////////////////////////////////////////////////////////////////
// 4. Stringify JSON
printf("\nModified JSON with reformatting:\n");
StringBuffer sb;
PrettyWriter<StringBuffer> writer(sb);
document.Accept(writer); // Accept() traverses the DOM and generates Handler events.
puts(sb.GetString());
return 0;
}
/* ****************************************************************************
*
* parseBatchUpdate -
*/
std::string parseBatchUpdate(ConnectionInfo* ciP, BatchUpdate* burP)
{
Document document;
document.Parse(ciP->payload);
if (document.HasParseError())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "JSON Parse Error");
ec.fill(ERROR_STRING_PARSERROR, "Errors found in incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
if (!document.IsObject())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "JSON Parse Error");
ec.fill("BadRequest", "JSON Parse Error");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
else if (document.ObjectEmpty())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "Empty JSON payload");
ec.fill("BadRequest", "empty payload");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
else if (!document.HasMember("entities"))
{
ErrorCode ec;
std::string details = "Invalid JSON payload, mandatory field /entities/ not found";
alarmMgr.badInput(clientIp, details);
ec.fill("BadRequest", details);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
else if (!document.HasMember("actionType"))
{
ErrorCode ec;
std::string details = "Invalid JSON payload, mandatory field /actionType/ not found";
alarmMgr.badInput(clientIp, details);
ec.fill("BadRequest", details);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string name = iter->name.GetString();
std::string type = jsonParseTypeNames[iter->value.GetType()];
if (name == "entities")
{
std::string r = parseEntityVector(ciP, iter, &burP->entities, true); // param 4: attributes are allowed in payload
if (r != "OK")
{
ErrorCode ec("BadRequest", r);
alarmMgr.badInput(clientIp, r);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
else if (name == "actionType")
{
burP->updateActionType.set(iter->value.GetString());
}
else
{
std::string description = std::string("Unrecognized field in JSON payload: /") + name + "/";
ErrorCode ec("BadRequest", description);
alarmMgr.badInput(clientIp, description);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
return "OK";
}
GameState* JsonEncodeDecode::decode(const char *buffer)
{
Document doc;
// Parse and catch errors
if (doc.Parse(buffer).HasParseError())
{
printf("\n----------\nError (offset %u): %s\n----------\n",
(unsigned)doc.GetErrorOffset(),
GetParseError_En(doc.GetParseError()));
return NULL;
}
// Create new GameState
GameState* state = new GameState();
// Iterate through JSON document
for (Value::ConstMemberIterator itr = doc.MemberBegin(); itr != doc.MemberEnd(); ++itr)
{
/*
* GAME OVER STATE
*/
if (strcmp(itr->name.GetString(), "GameOver") == 0)
{
int gameOver = itr->value.GetInt();
state->setGameOver(gameOver);
}
/*
* TIME TO RESTART
*/
if (strcmp(itr->name.GetString(), "SecToRestart") == 0)
{
int secToRestart = itr->value.GetInt();
state->setSecToRestart(secToRestart);
}
/*
* VEHICLES
*/
if (strcmp(itr->name.GetString(), "Vehicles") == 0)
{
// If Vehicles is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Vehicles array is not array\n----------\n");
return NULL;
}
const Value& vehicleArray = itr->value;
for (SizeType i = 0; i < vehicleArray.Size(); i++)
{
if (decodeVehicle(state, vehicleArray[i]) == -1)
{
printf("\n----------\nError decoding vehicles\n----------\n");
return NULL;
}
}
}
/*
* BULLETS
*/
if (strcmp(itr->name.GetString(), "Bullets") == 0)
{
// If Bullets is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Bullets array is not array\n----------\n");
return NULL;
}
const Value& bulletArray = itr->value;
for (SizeType i = 0; i < bulletArray.Size(); i++)
{
if (decodeBullet(state, bulletArray[i]) == -1)
{
printf("\n----------\nError decoding bullets\n----------\n");
return NULL;
}
}
}
/*
* BASES
*/
if (strcmp(itr->name.GetString(), "Bases") == 0)
{
// If Bases is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Bases array is not array\n----------\n");
return NULL;
}
const Value& basesArray = itr->value;
for (SizeType i = 0; i < basesArray.Size(); i++)
{
if (decodeBase(state, basesArray[i]) == -1)
{
printf("\n----------\nError decoding bases\n----------\n");
return NULL;
}
}
}
/*
* SHIELDS
*/
if (strcmp(itr->name.GetString(), "Shields") == 0)
{
// If Shields is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Shields array is not array\n----------\n");
return NULL;
}
const Value& shieldsArray = itr->value;
for (SizeType i = 0; i < shieldsArray.Size(); i++)
{
if (decodeShield(state, shieldsArray[i]) == -1)
{
printf("\n----------\nError decoding shields\n----------\n");
return NULL;
}
}
}
/*
* SHIELD GENERATORS
*/
if (strcmp(itr->name.GetString(), "ShieldGenerators") == 0)
{
// If ShieldGenerators is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Shield gens array is not array\n----------\n");
return NULL;
}
const Value& shieldGenArray = itr->value;
for (SizeType i = 0; i < shieldGenArray.Size(); i++)
{
if (decodeShieldGen(state, shieldGenArray[i]) == -1)
{
printf("\n----------\nError decoding shield gens\n----------\n");
return NULL;
}
}
}
/*
* POWERUPS
*/
if (strcmp(itr->name.GetString(), "PowerUps") == 0)
{
// If Powerups is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Powerups array is not array\n----------\n");
return NULL;
}
const Value& powerupArray = itr->value;
for (SizeType i = 0; i < powerupArray.Size(); i++)
{
if (decodePowerup(state, powerupArray[i]) == -1)
{
printf("\n----------\nError decoding powerups\n----------\n");
return NULL;
}
}
}
/*
* ROCKETS
*/
if (strcmp(itr->name.GetString(), "Rockets") == 0)
{
// If Rockets is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: Rockets array is not array\n----------\n");
return NULL;
}
const Value& rocketArray = itr->value;
for (SizeType i = 0; i < rocketArray.Size(); i++)
{
if (decodeRocket(state, rocketArray[i]) == -1)
{
printf("\n----------\nError decoding rockets\n----------\n");
return NULL;
}
}
}
/*
* GRAVITY WELLS
*/
if (strcmp(itr->name.GetString(), "GravityWells") == 0)
{
// If GravityWells is not an array, something went wrong
if (!itr->value.IsArray())
{
printf("\n----------\nError: GravityWells array is not array\n----------\n");
return NULL;
}
const Value& gravWellArray = itr->value;
for (SizeType i = 0; i < gravWellArray.Size(); i++)
{
if (decodeGravWell(state, gravWellArray[i]) == -1)
{
printf("\n----------\nError decoding gravity wells\n----------\n");
return NULL;
}
}
}
}
return state;
}
/* ****************************************************************************
*
* parseContextAttributeCompoundValueStandAlone -
*/
std::string parseContextAttributeCompoundValueStandAlone
(
Document& document,
ContextAttribute* caP,
orion::ValueType valueType
)
{
caP->compoundValueP = new orion::CompoundValueNode();
caP->compoundValueP->name = "TOP";
caP->compoundValueP->container = caP->compoundValueP;
caP->compoundValueP->valueType = caP->valueType; // Convert to other type?
caP->compoundValueP->path = "/";
caP->compoundValueP->rootP = caP->compoundValueP;
caP->compoundValueP->level = 0;
caP->compoundValueP->siblingNo = 0;
orion::CompoundValueNode* parent = caP->compoundValueP;
//
// Children of the node
//
if (caP->valueType == orion::ValueTypeVector)
{
int counter = 0;
for (Value::ConstValueIterator iter = document.Begin(); iter != document.End(); ++iter)
{
std::string nodeType = jsonParseTypeNames[iter->GetType()];
orion::CompoundValueNode* cvnP = new orion::CompoundValueNode();
char itemNo[4];
snprintf(itemNo, sizeof(itemNo), "%03d", counter);
cvnP->valueType = stringToCompoundType(nodeType);
cvnP->container = parent;
cvnP->rootP = parent->rootP;
cvnP->level = parent->level + 1;
cvnP->siblingNo = counter;
cvnP->path = parent->path + "[" + itemNo + "]";
if (nodeType == "String")
{
cvnP->stringValue = iter->GetString();
}
else if (nodeType == "Number")
{
cvnP->numberValue = iter->GetDouble();
}
else if ((nodeType == "True") || (nodeType == "False"))
{
cvnP->boolValue = (nodeType == "True")? true : false;
}
else if (nodeType == "Null")
{
cvnP->valueType = orion::ValueTypeNone;
}
else if (nodeType == "Object")
{
cvnP->path += "/";
cvnP->valueType = orion::ValueTypeObject;
}
else if (nodeType == "Array")
{
cvnP->path += "/";
cvnP->valueType = orion::ValueTypeVector;
}
parent->childV.push_back(cvnP);
//
// Start recursive calls if Object or Array
//
if ((nodeType == "Object") || (nodeType == "Array"))
{
parseContextAttributeCompoundValue(iter, caP, cvnP);
}
else if (!caP->typeGiven)
{
caP->type = defaultType(caP->valueType);
}
++counter;
}
}
else if (caP->valueType == orion::ValueTypeObject)
{
int counter = 0;
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string nodeType = jsonParseTypeNames[iter->value.GetType()];
orion::CompoundValueNode* cvnP = new orion::CompoundValueNode();
cvnP->name = iter->name.GetString();
cvnP->valueType = stringToCompoundType(nodeType);
cvnP->container = parent;
cvnP->rootP = parent->rootP;
cvnP->level = parent->level + 1;
cvnP->siblingNo = counter;
cvnP->path = parent->path + cvnP->name;
if (nodeType == "String")
{
cvnP->stringValue = iter->value.GetString();
}
else if (nodeType == "Number")
{
cvnP->numberValue = iter->value.GetDouble();
}
else if ((nodeType == "True") || (nodeType == "False"))
{
cvnP->boolValue = (nodeType == "True")? true : false;
}
else if (nodeType == "Null")
{
cvnP->valueType = orion::ValueTypeNone;
}
else if (nodeType == "Object")
{
cvnP->path += "/";
cvnP->valueType = orion::ValueTypeObject;
}
else if (nodeType == "Array")
{
cvnP->path += "/";
cvnP->valueType = orion::ValueTypeVector;
}
parent->childV.push_back(cvnP);
//
// Start recursive calls if Object or Array
//
if ((nodeType == "Object") || (nodeType == "Array"))
{
parseContextAttributeCompoundValue(iter, caP, cvnP);
}
else if (!caP->typeGiven)
{
caP->type = defaultType(caP->valueType);
}
++counter;
}
}
return "OK";
}
/* ****************************************************************************
*
* parseAttributeValue -
*/
std::string parseAttributeValue(ConnectionInfo* ciP, ContextAttribute* caP)
{
Document document;
OrionError oe;
document.Parse(ciP->payload);
if (document.HasParseError())
{
LM_W(("Bad Input (JSON parse error)"));
oe.fill(SccBadRequest, "Errors found in incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;;
return oe.render(ciP, "");
}
if (!document.IsObject())
{
LM_E(("Bad Input (JSON Parse Error)"));
oe.fill(SccBadRequest, "Error parsing incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;;
return oe.render(ciP, "");
}
if (!document.HasMember("value"))
{
LM_W(("Bad Input (No attribute value specified"));
oe.fill(SccBadRequest, "no attribute value specified");
ciP->httpStatusCode = SccBadRequest;;
return oe.render(ciP, "");
}
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string name = iter->name.GetString();
std::string type = jsonParseTypeNames[iter->value.GetType()];
if (name != "value")
{
LM_W(("Bad Input (unexpected JSON field - accepting only 'value'"));
oe.fill(SccBadRequest, "unexpected JSON field - accepting only /value/");
ciP->httpStatusCode = SccBadRequest;;
return oe.render(ciP, "");
}
if (type == "String")
{
caP->valueType = orion::ValueTypeString;
caP->stringValue = iter->value.GetString();
}
else if (type == "Number")
{
caP->numberValue = iter->value.GetDouble();
caP->valueType = orion::ValueTypeNumber;
}
else if (type == "True")
{
caP->boolValue = true;
caP->valueType = orion::ValueTypeBoolean;
}
else if (type == "False")
{
caP->boolValue = false;
caP->valueType = orion::ValueTypeBoolean;
}
else if (type == "Array")
{
caP->valueType = orion::ValueTypeVector;
std::string r = parseContextAttributeCompoundValue(iter, caP, NULL);
if (r != "OK")
{
LM_W(("Bad Input (json error in ContextAttributeObject::Vector"));
return "json error in ContextAttributeObject::Vector";
}
}
else if (type == "Object")
{
caP->valueType = orion::ValueTypeObject;
std::string r = parseContextAttributeCompoundValue(iter, caP, NULL);
if (r != "OK")
{
LM_W(("Bad Input (json error in ContextAttributeObject::Object"));
return "json error in ContextAttributeObject::Object";
}
}
}
return "OK";
}
/* ****************************************************************************
*
* parseEntity -
*
* This function is used to parse two slightly different payloads:
* - POST /v2/entities
* - POST /v2/entities/<eid>
*
* In the latter case, "id" CANNOT be in the payload, while in the former case,
* "id" MUST be in the payload.
*
* In the case of /v2/entities/<eid>, the entityId of 'Entity* eP' is set in
* the service routine postEntity.
*
*/
std::string parseEntity(ConnectionInfo* ciP, Entity* eP, bool eidInURL)
{
Document document;
document.Parse(ciP->payload);
if (document.HasParseError())
{
LM_W(("Bad Input (JSON parse error)"));
eP->errorCode.fill("ParseError", "Errors found in incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
if (!document.IsObject())
{
LM_E(("Bad Input (JSON Parse Error)"));
eP->errorCode.fill("ParseError", "Error parsing incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
if (eidInURL == false)
{
if (!document.HasMember("id"))
{
LM_W(("Bad Input (No entity id specified"));
eP->errorCode.fill("ParseError", "no entity id specified");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string name = iter->name.GetString();
std::string type = jsonParseTypeNames[iter->value.GetType()];
if (name == "id")
{
if (eidInURL == false)
{
if (type != "String")
{
LM_W(("Bad Input (invalid JSON type for entity id"));
eP->errorCode.fill("ParseError", "invalid JSON type for entity id");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
eP->id = iter->value.GetString();
}
else // "id" present in payload for /v2/entities/<eid> - not a valid payload
{
LM_W(("Bad Input ('id' is not a valid attribute"));
eP->errorCode.fill("ParseError", "invalid input, 'id' as attribute");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
else if (name == "type")
{
if (type != "String")
{
LM_W(("Bad Input (invalid JSON type for entity type"));
eP->errorCode.fill("ParseError", "invalid JSON type for entity type");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
eP->type = iter->value.GetString();
}
else
{
ContextAttribute* caP = new ContextAttribute();
eP->attributeVector.push_back(caP);
std::string r = parseContextAttribute(ciP, iter, caP);
if (r != "OK")
{
LM_W(("Bad Input (parse error in context attribute)"));
eP->errorCode.fill("ParseError", r);
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
}
}
if (eidInURL == false)
{
if (eP->id == "")
{
LM_W(("Bad Input (empty entity id"));
eP->errorCode.fill("ParseError", "empty entity id");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
eP->present("");
return "OK";
}
void convertMultiple(const char* nameJSON, const char* nameCSV) {
//Prepare Input
struct stat statbuf;
stat(nameJSON, &statbuf);
size_t fsize = statbuf.st_size;
int fd = open(nameJSON, O_RDONLY);
if (fd == -1) {
throw runtime_error(string("json.open"));
}
const char *bufJSON = (const char*) mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, 0);
if (bufJSON == MAP_FAILED) {
throw runtime_error(string("json.mmap"));
}
//Prepare output
ofstream outFile;
outFile.open(nameCSV);
//Input loop
size_t obj_start = 0;
size_t obj_end = 0;
char *line_bufJSON = NULL;
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
stringstream ss;
int flushCount = 0;
while (obj_start < fsize) {
size_t i = obj_start;
for (; bufJSON[i] != '\n'; i++) {}
obj_end = i;
line_bufJSON = new char[obj_end - obj_start + 1];
line_bufJSON[obj_end - obj_start] = '\0';
memcpy(line_bufJSON, bufJSON + obj_start, obj_end - obj_start);
//Triggering parser
Document d;
d.Parse(line_bufJSON);
Value::ConstMemberIterator itrDoc = d.MemberBegin();
Value::ConstMemberIterator itrDocEnd = d.MemberEnd();
buffer.Clear();
writer.Reset(buffer);
//1st iteration unrolled to avoid unnecessary "if(first)" checks
if (itrDoc != itrDocEnd) {
if (itrDoc->value.IsObject()) {
Value::ConstMemberIterator itr_ = itrDoc->value.MemberBegin();
Value::ConstMemberIterator itrEnd_ = itrDoc->value.MemberEnd();
iterateObject(itr_, itrEnd_, &buffer, &writer, ss);
} else if (itrDoc->value.IsArray()) {
Value::ConstValueIterator itr_ = itrDoc->value.Begin();
Value::ConstValueIterator itrEnd_ = itrDoc->value.End();
iterateArray(itr_, itrEnd_, &buffer, &writer, ss);
} else if (itrDoc->value.IsBool()) {
ss << itrDoc->value.GetBool();
} else if (itrDoc->value.IsInt()) {
ss << itrDoc->value.GetInt();
} else if (itrDoc->value.IsInt64()) {
ss << itrDoc->value.GetInt64();
} else if (itrDoc->value.IsDouble()) {
ss << itrDoc->value.GetDouble();
} else if (itrDoc->value.IsString()) {
ss << "\"" << itrDoc->value.GetString() << "\"";
} else {
throw runtime_error(string("Case missing from tokenizer"));
}
}
itrDoc++;
iterateObject(itrDoc, itrDocEnd, &buffer, &writer, ss);
ss << "\n";
//flushing to output file every 1000 entries
flushCount++;
if(flushCount % 1000 == 0) {
outFile << ss.rdbuf();
ss.clear();
}
//Prepare next loop + cleanup
delete line_bufJSON;
obj_start = ++i;
}
outFile << ss.rdbuf();
outFile.close();
close(fd);
munmap((void*) bufJSON,fsize);
}
void convert(const char* nameJSON, const char* nameCSV) {
//Prepare Input
struct stat statbuf;
stat(nameJSON, &statbuf);
size_t fsize = statbuf.st_size;
int fd = open(nameJSON, O_RDONLY);
if (fd == -1) {
throw runtime_error(string("json.open"));
}
const char *bufJSON = (const char*) mmap(NULL, fsize, PROT_READ, MAP_PRIVATE, fd, 0);
if (bufJSON == MAP_FAILED) {
throw runtime_error(string("json.mmap"));
}
//Prepare output
ofstream outFile;
outFile.open(nameCSV);
Document d;
d.Parse(bufJSON);
StringBuffer buffer;
Writer<StringBuffer> writer(buffer);
stringstream ss;
Value::ConstMemberIterator itrDoc = d.MemberBegin();
Value::ConstMemberIterator itrDocEnd = d.MemberEnd();
if (itrDoc != itrDocEnd) {
if (itrDoc->value.IsObject()) {
Value::ConstMemberIterator itr_ = itrDoc->value.MemberBegin();
Value::ConstMemberIterator itrEnd_ = itrDoc->value.MemberEnd();
iterateObject(itr_, itrEnd_, &buffer, &writer, ss);
} else if (itrDoc->value.IsArray()) {
Value::ConstValueIterator itr_ = itrDoc->value.Begin();
Value::ConstValueIterator itrEnd_ = itrDoc->value.End();
iterateArray(itr_, itrEnd_, &buffer, &writer, ss);
} else if (itrDoc->value.IsBool()) {
ss << itrDoc->value.GetBool();
} else if (itrDoc->value.IsInt()) {
ss << itrDoc->value.GetInt();
} else if (itrDoc->value.IsInt64()) {
ss << itrDoc->value.GetInt64();
} else if (itrDoc->value.IsDouble()) {
ss << itrDoc->value.GetDouble();
} else if (itrDoc->value.IsString()) {
ss << "\"" << itrDoc->value.GetString() << "\"";
} else {
throw runtime_error(string("Case missing from tokenizer"));
}
}
itrDoc++;
iterateObject(itrDoc, itrDocEnd, &buffer, &writer, ss);
outFile << ss.rdbuf();
outFile.close();
close(fd);
munmap((void*) bufJSON,fsize);
}
/* ****************************************************************************
*
* parseEntity -
*
* This function is used to parse two slightly different payloads:
* - POST /v2/entities
* - POST /v2/entities/<eid>
*
* In the latter case, "id" CANNOT be in the payload, while in the former case,
* "id" MUST be in the payload.
*
* In the case of /v2/entities/<eid>, the entityId of 'Entity* eP' is set in
* the service routine postEntity.
*
* Also, if the URI param 'options' includes the value 'keyValues', then the
* parse changes for compound values of attributes. If the value is a JSON object
* then there is no looking inside to find the 'value' field, but the attribute is
* always treated as a compound attribute.
*
*/
std::string parseEntity(ConnectionInfo* ciP, Entity* eP, bool eidInURL)
{
Document document;
document.Parse(ciP->payload);
if (document.HasParseError())
{
alarmMgr.badInput(clientIp, "JSON parse error");
eP->oe.fill(SccBadRequest, "Errors found in incoming JSON buffer", ERROR_STRING_PARSERROR);
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
if (!document.IsObject())
{
alarmMgr.badInput(clientIp, "JSON Parse Error");
eP->oe.fill(SccBadRequest, "Errors found in incoming JSON buffer", ERROR_STRING_PARSERROR);
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
if (eidInURL == false)
{
if (!document.HasMember("id"))
{
alarmMgr.badInput(clientIp, "No entity id specified");
eP->oe.fill(SccBadRequest, "no entity id specified", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
if (eidInURL == true)
{
if (document.HasMember("id"))
{
alarmMgr.badInput(clientIp, "entity id specified in payload");
eP->oe.fill(SccBadRequest, "entity id specified in payload", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
if (document.HasMember("type"))
{
alarmMgr.badInput(clientIp, "entity type specified in payload");
eP->oe.fill(SccBadRequest, "entity type specified in payload", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
else if (document.ObjectEmpty())
{
//
// Initially we used the method "Empty". As the broker crashed inside that method, some
// research was made and "ObjectEmpty" was found. As the broker stopped crashing and complaints
// about crashes with small docs and "Empty()" were found on the internet, we opted to use ObjectEmpty
//
alarmMgr.badInput(clientIp, "Empty payload");
eP->oe.fill(SccBadRequest, "empty payload", "BadRequest");
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
int membersFound = 0;
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string name = iter->name.GetString();
std::string type = jsonParseTypeNames[iter->value.GetType()];
++membersFound;
if (name == "id")
{
if (eidInURL == false)
{
if (type != "String")
{
alarmMgr.badInput(clientIp, "invalid JSON type for entity id");
eP->oe.fill(SccBadRequest, "invalid JSON type for entity id", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
eP->id = iter->value.GetString();
}
else // "id" is present in payload for /v2/entities/<eid> - not a valid payload
{
alarmMgr.badInput(clientIp, "'id' is not a valid attribute");
eP->oe.fill(SccBadRequest, "invalid input, 'id' as attribute", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
}
else if (name == "type")
{
if (type != "String")
{
alarmMgr.badInput(clientIp, "invalid JSON type for entity type");
eP->oe.fill(SccBadRequest, "invalid JSON type for entity type", "BadRequest");
ciP->httpStatusCode = SccBadRequest;;
return eP->render(ciP, EntitiesRequest);
}
eP->type = iter->value.GetString();
eP->typeGiven = true;
}
else // attribute
{
ContextAttribute* caP = new ContextAttribute();
eP->attributeVector.push_back(caP);
std::string r = parseContextAttribute(ciP, iter, caP);
if (r != "OK")
{
alarmMgr.badInput(clientIp, "parse error in context attribute");
eP->oe.fill(SccBadRequest, r, "BadRequest");
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
}
}
if (membersFound == 0)
{
eP->oe.fill(SccBadRequest, "empty payload", "BadRequest");
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
if (eidInURL == false)
{
if (eP->id == "")
{
alarmMgr.badInput(clientIp, "empty entity id");
eP->oe.fill(SccBadRequest, "empty entity id", "BadRequest");
ciP->httpStatusCode = SccBadRequest;
return eP->render(ciP, EntitiesRequest);
}
}
if (!eP->typeGiven)
{
eP->type = DEFAULT_ENTITY_TYPE;
}
return "OK";
}
/* ****************************************************************************
*
* parseBatchQuery -
*/
std::string parseBatchQuery(ConnectionInfo* ciP, BatchQuery* bqrP)
{
Document document;
document.Parse(ciP->payload);
if (document.HasParseError())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "JSON Parse Error");
ec.fill(ERROR_STRING_PARSERROR, "Errors found in incoming JSON buffer");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
if (!document.IsObject())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "JSON Parse Error");
ec.fill("BadRequest", "JSON Parse Error");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
else if (document.ObjectEmpty())
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "Empty JSON payload");
ec.fill("BadRequest", "empty payload");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
else if (!document.HasMember("entities") && !document.HasMember("attributes") && !document.HasMember("scopes"))
{
ErrorCode ec;
alarmMgr.badInput(clientIp, "Invalid JSON payload, no relevant fields found");
ec.fill("BadRequest", "Invalid JSON payload, no relevant fields found");
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
for (Value::ConstMemberIterator iter = document.MemberBegin(); iter != document.MemberEnd(); ++iter)
{
std::string name = iter->name.GetString();
std::string type = jsonParseTypeNames[iter->value.GetType()];
if (name == "entities")
{
std::string r = parseEntityVector(ciP, iter, &bqrP->entities, false); // param 4: attributes are NOT allowed in payload
if (r != "OK")
{
ErrorCode ec("BadRequest", r);
alarmMgr.badInput(clientIp, r);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
else if (name == "attributes")
{
std::string r = parseAttributeList(ciP, iter, &bqrP->attributeV);
if (r != "OK")
{
ErrorCode ec("BadRequest", r);
alarmMgr.badInput(clientIp, r);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
else if (name == "scopes")
{
std::string r = parseScopeVector(ciP, iter, &bqrP->scopeV);
if (r != "OK")
{
ErrorCode ec("BadRequest", r);
alarmMgr.badInput(clientIp, r);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
else
{
std::string description = std::string("Unrecognizedfield in JSON payload: /") + name + "/";
ErrorCode ec("BadRequest", description);
alarmMgr.badInput(clientIp, description);
ciP->httpStatusCode = SccBadRequest;
return ec.toJson(true);
}
}
return "OK";
}