void plugin_options::parse_json(std::string path)
{
// first try to open as a directory
osd_directory *directory = osd_opendir(path.c_str());
if (directory != nullptr)
{
// iterate over all files in the directory
for (const osd_directory_entry *entry = osd_readdir(directory); entry != nullptr; entry = osd_readdir(directory))
{
if (entry->type == ENTTYPE_FILE)
{
std::string name = entry->name;
if (name == "plugin.json")
{
std::string curfile = std::string(path).append(PATH_SEPARATOR).append(entry->name);
std::ifstream ifs(curfile);
rapidjson::IStreamWrapper isw(ifs);
rapidjson::Document document;
document.ParseStream<0>(isw);
if (document.HasParseError()) {
std::string error(GetParseError_En(document.GetParseError()));
osd_printf_error("Unable to parse plugin definition file %s. Errors returned:\n", curfile.c_str());
osd_printf_error("%s\n", error.c_str());
return;
}
if (document["plugin"].IsObject())
{
std::string name = document["plugin"]["name"].GetString();
std::string description = document["plugin"]["description"].GetString();
std::string type = document["plugin"]["type"].GetString();
bool start = false;
if (document["plugin"].HasMember("start") && (std::string(document["plugin"]["start"].GetString()) == "true"))
start = true;
if (type=="plugin")
{
add_entry(core_strdup(name.c_str()),core_strdup(description.c_str()), OPTION_BOOLEAN, start ? "1" : "0");
}
}
}
}
else if (entry->type == ENTTYPE_DIR)
{
std::string name = entry->name;
if (!(name == "." || name == ".."))
{
parse_json(path + PATH_SEPARATOR + name);
}
}
}
// close the directory and be done
osd_closedir(directory);
}
}
static PyObject *
pyrapidjson_load(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {(char *)"text", NULL};
PyObject *py_file, *py_string, *read_method;
char *text;
rapidjson::Document doc;
/* Parse arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", kwlist, &py_file))
return NULL;
if (!PyObject_HasAttrString(py_file, "read")) {
PyErr_Format(PyExc_TypeError, "expected file object. has not read() method.");
return NULL;
}
read_method = PyObject_GetAttrString(py_file, "read");
if (!PyCallable_Check(read_method)) {
Py_XDECREF(read_method);
PyErr_Format(PyExc_TypeError, "expected file object. read() method is not callable.");
return NULL;
}
py_string = PyObject_CallObject(read_method, NULL);
if (py_string == NULL) {
Py_XDECREF(read_method);
return NULL;
}
#ifdef PY3
PyObject *utf8_item;
utf8_item = PyUnicode_AsUTF8String(py_string);
text = PyBytes_AsString(utf8_item);
#else
text = PyString_AsString(py_string);
#endif
doc.Parse(text);
if (doc.HasParseError()) {
Py_XDECREF(read_method);
Py_XDECREF(py_string);
PyErr_SetString(PyExc_ValueError, GetParseError_En(doc.GetParseError()));
return NULL;
}
Py_XDECREF(read_method);
Py_XDECREF(py_string);
PyObject *ret = _doc2pyobj(doc, text);
#ifdef PY3
Py_XDECREF(utf8_item);
#endif
return ret;
}
void SettingsTree::loadFromJSON(std::istream &is)
{
Util::RapidJSON::IStreamWrapper stream(is);
rapidjson::Document document;
document.ParseStream(stream);
if (document.HasParseError())
{
throw std::runtime_error("Parse error at offset " +
std::to_string(document.GetErrorOffset()) +
": " +
GetParseError_En(document.GetParseError()));
}
parseValue(myTree, document);
}
static PyObject *
pyrapidjson_loads(PyObject *self, PyObject *args, PyObject *kwargs)
{
static char *kwlist[] = {(char *)"text", NULL};
char *text;
rapidjson::Document doc;
/* Parse arguments */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", kwlist, &text))
return NULL;
doc.Parse(text);
if (doc.HasParseError()) {
PyErr_SetString(PyExc_ValueError, GetParseError_En(doc.GetParseError()));
return NULL;
}
return _doc2pyobj(doc, text);
}
JSON_API void read_json(std::string const &fname, rapidjson::Document &d)
{
FILE* fp = fopen(fname.c_str(), "rb"); // non-Windows use "r"
if(!fp)
{
std::stringstream str; str << "ERROR [read_json]: file " << fname << " not found!";
throw std::runtime_error(str.str());
}
fseek(fp, 0, SEEK_END);
size_t length = static_cast<size_t>(ftell(fp));
//std::cout << "file size = " << length << std::endl;
fseek(fp, 0, SEEK_SET);
char* readBuffer = static_cast<char*>(malloc(length + 1));
size_t readLength = fread(readBuffer, 1, length, fp);
readBuffer[readLength] = '\0';
fclose(fp);
d.Parse<rapidjson::kParseCommentsFlag>(readBuffer);
if(d.HasParseError())
{
std::stringstream str;
str << "ERROR [read_json]: json document cannot be parsed!" << std::endl;
str << "\t Parse Error " << d.GetParseError() << " (" << GetParseError_En(d.GetParseError()) << ")" << std::endl;
str << "\t Error offset = " << d.GetErrorOffset() << '\n';
throw std::runtime_error(str.str());
}
if(!d.IsObject())
{
std::stringstream str;
str << "ERROR [read_json]: json document is not an object!";
throw std::runtime_error(str.str());
}
}
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;
}
int SettingRegistry::loadJSON(std::string filename)
{
rapidjson::Document json_document;
{
FILE* f = fopen(filename.c_str(), "rb");
if (!f)
{
cura::logError("Couldn't open JSON file.\n");
return 1;
}
char read_buffer[4096];
rapidjson::FileReadStream reader_stream(f, read_buffer, sizeof(read_buffer));
json_document.ParseStream(reader_stream);
fclose(f);
if (json_document.HasParseError())
{
cura::logError("Error(offset %u): %s\n", (unsigned)json_document.GetErrorOffset(), GetParseError_En(json_document.GetParseError()));
return 2;
}
}
if (!json_document.IsObject())
{
cura::logError("JSON file is not an object.\n");
return 3;
}
if (json_document.HasMember("machine_extruder_trains"))
{
categories.emplace_back("machine_extruder_trains", "Extruder Trains Settings Objects");
SettingCategory* category_trains = &categories.back();
const rapidjson::Value& trains = json_document["machine_extruder_trains"];
if (trains.IsArray())
{
if (trains.Size() > 0 && trains[0].IsObject())
{
unsigned int idx = 0;
for (auto it = trains.Begin(); it != trains.End(); ++it)
{
SettingConfig* child = category_trains->addChild(std::to_string(idx), std::to_string(idx));
_addSettingsToCategory(category_trains, *it, child, false);
idx++;
}
}
}
else
{
logError("Error: JSON machine_extruder_trains is not an array!\n");
}
}
if (json_document.HasMember("machine_settings"))
{
categories.emplace_back("machine_settings", "Machine Settings");
SettingCategory* category_machine_settings = &categories.back();
_addSettingsToCategory(category_machine_settings, json_document["machine_settings"], NULL);
}
if (json_document.HasMember("categories"))
{
for (rapidjson::Value::ConstMemberIterator category_iterator = json_document["categories"].MemberBegin(); category_iterator != json_document["categories"].MemberEnd(); ++category_iterator)
{
if (!category_iterator->value.IsObject())
{
continue;
}
if (!category_iterator->value.HasMember("label") || !category_iterator->value["label"].IsString())
{
continue;
}
if (!category_iterator->value.HasMember("settings") || !category_iterator->value["settings"].IsObject())
{
continue;
}
categories.emplace_back(category_iterator->name.GetString(), category_iterator->value["label"].GetString());
SettingCategory* category = &categories.back();
_addSettingsToCategory(category, category_iterator->value["settings"], NULL);
}
}
return 0;
}
// Main Method
int main(int argc, char** argv) {
// Set up a handler for any signals so that we always shutdown gracefully
struct sigaction sigIntHandler;
sigIntHandler.sa_handler = my_signal_handler;
sigemptyset(&sigIntHandler.sa_mask);
sigIntHandler.sa_flags = 0;
sigaction(SIGINT, &sigIntHandler, NULL);
// Setup the component factories
cli_factory = new CommandLineInterpreterFactory;
uuid_factory = new uuidComponentFactory;
zmq_factory = new ZmqComponentFactory;
logging_factory = new LoggingComponentFactory;
mongo_factory = new MongoComponentFactory;
ObjectListFactory ofactory;
ObjectFactory objfactory;
// Set up our command line interpreter
cli = cli_factory->get_command_line_interface(argc, argv);
// Allow for wait on startup, if configured
if (cli->opt_exist("-wait")) {
std::string wait_time_string = cli->get_opt("-wait");
int wait_time = std::stoi(wait_time_string, NULL);
// Accept input on the command line in seconds, convert to microseconds
usleep(wait_time * 1000000);
}
// Set up logging
std::string initFileName;
// See if we have a command line setting for the log file
const char * env_logging_file = std::getenv("CRAZYIVAN_LOGGING_CONF");
if (env_logging_file) {
std::string tempFileName(env_logging_file);
initFileName = tempFileName;
} else if (cli->opt_exist("-log-conf")) {
initFileName = cli->get_opt("-log-conf");
} else {
initFileName = "log4cpp.properties";
}
// This reads the logging configuration file
logging = logging_factory->get_logging_interface(initFileName);
// Set up the logging submodules for each category
start_logging_submodules();
// Set up the UUID Generator
uid = uuid_factory->get_uuid_interface();
std::string service_id = "Clyman";
// Set up our configuration manager with the CLI
config = new ConfigurationManager(cli, service_id);
// Start up the Kafka Producer
kafka = new KafkaClient();
// The configuration manager will look at any command line arguments,
// configuration files, and Consul connections to try and determine the
// correct configuration for the service
// The configuration manager will look at any command line arguments,
// configuration files, and Consul connections to try and determine the
// correct configuration for the service
bool config_success = false;
bool config_tried = false;
int config_attempts = 0;
// If we fail configuration, we should sleep for 5 seconds and try again
while (!config_success) {
if (config_attempts > 50) {
main_logging->error("Max Config Attempts failed, exiting");
shutdown();
exit(1);
}
if (config_tried) {
main_logging->error("Configuration Failed, trying again in 5 seconds");
usleep(5000000);
} else {
config_tried = true;
}
try {
config_success = config->configure();
}
catch (std::exception& e) {
main_logging->error("Exception encountered during Configuration");
}
}
// Set up the Mongo Connection
std::string DBConnStr = config->get_mongoconnstr();
std::string DBName = config->get_dbname();
std::string DBHeaderCollection = config->get_dbheadercollection();
if (!(DBConnStr.empty() || DBName.empty() \
|| DBHeaderCollection.empty())) {
try {
mongo = mongo_factory->get_mongo_interface(DBConnStr, \
DBName, DBHeaderCollection);
main_logging->debug("Connected to Mongo");
}
catch (std::exception& e) {
main_logging->error("Exception encountered during Mongo Startup");
main_logging->error(e.what());
shutdown();
exit(1);
}
} else {
main_logging->error("Insufficient Mongo Connection Information");
shutdown();
exit(1);
}
// Connect to the inbound ZMQ Admin
std::string ib_zmq_connstr = config->get_ibconnstr();
if (!(ib_zmq_connstr.empty())) {
zmqi = zmq_factory->get_zmq_inbound_interface(ib_zmq_connstr, REQ_RESP);
main_logging->info("ZMQ Socket Open, opening request loop");
} else {
main_logging->error("No IB ZMQ Connection String Supplied");
shutdown();
exit(1);
}
// Main Request Loop
while (true) {
std::string resp_str = "";
rapidjson::Document d;
protoObj3::Obj3List new_proto;
// Convert the OMQ message into a string to be passed on the event
char * req_ptr = zmqi->crecv();
if (!req_ptr) continue;
main_logging->debug("Conversion to C String performed with result: ");
main_logging->debug(req_ptr);
// Trim the string recieved
std::string recvd_msg(req_ptr);
std::string clean_string;
std::string new_error_message = "";
// Parsing logic - JSON
if (config->get_formattype() == JSON_FORMAT) {
response_message = ofactory.build_json_object_list();
int final_closing_char = recvd_msg.find_last_of("}");
int first_opening_char = recvd_msg.find_first_of("{");
clean_string = \
recvd_msg.substr(first_opening_char, final_closing_char+1);
main_logging->debug("Input String Cleaned");
main_logging->debug(clean_string);
try {
d.Parse<rapidjson::kParseStopWhenDoneFlag>(clean_string.c_str());
if (d.HasParseError()) {
main_logging->error("Parsing Error: ");
main_logging->error(GetParseError_En(d.GetParseError()));
response_message->set_error_code(TRANSLATION_ERROR);
new_error_message.assign(GetParseError_En(d.GetParseError()));
} else {inbound_message = ofactory.build_object_list(d);}
}
// Catch a possible error and write to logs
catch (std::exception& e) {
main_logging->error("Exception occurred while parsing document:");
main_logging->error(e.what());
}
// Parsing logic - Protocol Buffers
} else if (config->get_formattype() == PROTO_FORMAT) {
response_message = ofactory.build_proto_object_list();
clean_string = trim(recvd_msg);
main_logging->debug("Input String Cleaned");
main_logging->debug(clean_string);
try {
new_proto.ParseFromString(clean_string);
inbound_message = ofactory.build_object_list(new_proto);
} catch (std::exception& e) {
main_logging->error("Exception occurred while parsing bytes:");
main_logging->error(e.what());
response_message->set_error_code(TRANSLATION_ERROR);
new_error_message.assign(e.what());
}
}
// Determine the Transaction ID
UuidContainer id_container;
id_container.id = "";
if (config->get_transactionidsactive() && inbound_message) {
// Get an existing transaction ID
std::string existing_trans_id = \
inbound_message->get_transaction_id();
// If no transaction ID is sent in, generate a new one
if (existing_trans_id.empty()) {
try {
id_container = uid->generate();
if (!id_container.err.empty()) {
main_logging->error(id_container.err);
}
inbound_message->set_transaction_id(id_container.id);
}
catch (std::exception& e) {
main_logging->error("Exception encountered in UUID Generation");
main_logging->error(e.what());
shutdown();
exit(1);
}
}
main_logging->debug("Transaction ID: ");
main_logging->debug(inbound_message->get_transaction_id());
}
bool shutdown_needed = false;
// Core application logic
if (inbound_message) {
try {
// Object Creation
if (inbound_message->get_msg_type() == OBJ_CRT) {
main_logging->info("Processing Object Creation Message");
for (int i = 0; i < inbound_message->num_objects(); i++) {
// Create a new Obj3 to add to the return list
ObjectInterface *resp_element = objfactory.build_object();
// Create the Obj3 document for Mongo
AOSSL::MongoBufferInterface *bson = mongo_factory->get_mongo_buffer();
inbound_message->get_object(i)->to_bson(bson);
MongoResponseInterface *resp = mongo->create_document(bson);
delete bson;
// Add the key into the new obj3
resp_element->set_key(resp->get_value());
// Add the new obj3 to the response list
response_message->add_object(resp_element);
delete resp;
}
// Object Update
} else if (inbound_message->get_msg_type() == OBJ_UPD || \
inbound_message->get_msg_type() == OBJ_LOCK || \
inbound_message->get_msg_type() == OBJ_UNLOCK ||
inbound_message->get_msg_type() == OBJ_OVERWRITE) {
main_logging->info("Processing Object Update Message");
for (int i = 0; i < inbound_message->num_objects(); i++) {
// Build a query bson to pass to the update_by_query
AOSSL::MongoBufferInterface *query_bson = mongo_factory->get_mongo_buffer();
AOSSL::MongoBufferInterface *bson = mongo_factory->get_mongo_buffer();
std::string msg_key = inbound_message->get_object(i)->get_key();
bool execute_query = true;
if (msg_key.empty() && \
!(inbound_message->get_object(i)->get_name().empty() && \
inbound_message->get_object(i)->get_scene().empty())) {
std::string name_key = "name";
std::string scene_key = "scene";
query_bson->add_string(name_key, inbound_message->get_object(i)->get_name());
query_bson->add_string(scene_key, inbound_message->get_object(i)->get_scene());
} else if (!(msg_key.empty())) {
query_bson->add_oid(msg_key);
}
// Add an owner query if object locking is active
if (config->get_locking_active()) {
std::string owner_key = "owner";
// If we have a lock message, then look for an empty owner
if (inbound_message->get_msg_type() == OBJ_LOCK) {
std::string owner_search = "";
query_bson->add_string(owner_key, owner_search);
// Otherwise, look for a matching owner to the input
} else {
std::string owner_search = inbound_message->get_object(i)->get_owner();
query_bson->add_string(owner_key, owner_search);
}
}
if (inbound_message->get_msg_type() == OBJ_OVERWRITE) {
// Build the BSON Update
main_logging->debug("Overwriting BSON Object");
inbound_message->get_object(i)->to_bson_update(bson);
} else {
// Load the current doc from the database
rapidjson::Document resp_doc;
MongoResponseInterface *resp = mongo->load_document(msg_key);
if (resp) {
std::string mongo_resp_str = resp->get_value();
main_logging->debug("Document loaded from Mongo");
main_logging->debug(mongo_resp_str);
resp_doc.Parse(mongo_resp_str.c_str());
ObjectInterface *resp_obj = objfactory.build_object(resp_doc);
// Save the resulting object
if (inbound_message->get_op_type() == APPEND) {
// Apply the object message as changes to the DB Object
resp_obj->merge(inbound_message->get_object(i));
// Update the object in case of unlock to have no owner before saving
if (inbound_message->get_msg_type() == OBJ_UNLOCK) {
std::string new_owner = "";
resp_obj->set_owner(new_owner);
}
resp_obj->to_bson_update(bson);
} else {
// Update the object in case of unlock to have no owner before saving
if (inbound_message->get_msg_type() == OBJ_UNLOCK) {
std::string new_owner = "";
inbound_message->get_object(0)->set_owner(new_owner);
}
inbound_message->get_object(0)->to_bson_update(true, false, bson);
}
response_message->add_object(resp_obj);
delete resp;
} else {
main_logging->error("Document not found in Mongo");
response_message->set_error_code(NOT_FOUND);
new_error_message = "Object not Found";
response_message->set_error_message(new_error_message);
execute_query = false;
}
}
// Actually execute the Mongo update
AOSSL::MongoBufferInterface *response_buffer = NULL;
bool send_update = false;
if (execute_query) {
response_buffer = mongo->update_single_by_query(query_bson, bson);
// Look at the response buffer to ensure that a single document
// was matched and updated
std::string mdc_key = "modifiedCount";
std::string mtc_key = "matchedCount";
int num_modified = response_buffer->get_int(mdc_key);
int num_matched = response_buffer->get_int(mtc_key);
if (num_matched == 0) {
main_logging->error("Document not found in Mongo");
response_message->set_error_code(NOT_FOUND);
new_error_message = "Object not Found";
response_message->set_error_message(new_error_message);
} else if (num_modified == 0) {
main_logging->error("Document found in Mongo, but update failed");
response_message->set_error_code(LOCK_EXISTS_ERROR);
new_error_message = "Object locked by another device";
response_message->set_error_message(new_error_message);
} else {
// Updates were successful in Mongo, so send via streams
send_update = true;
}
}
// Send an update on the Kafka 'dvs' topic
if ((inbound_message->get_msg_type() == OBJ_OVERWRITE || \
inbound_message->get_msg_type() == OBJ_UPD) && send_update) {
kafka->send(inbound_message->get_object(i)->to_transform_json(), config->get_kafkabroker());
}
delete query_bson;
delete bson;
}
// Object Retrieve
} else if (inbound_message->get_msg_type() == OBJ_GET) {
main_logging->info("Processing Object Get Message");
for (int i = 0; i < inbound_message->num_objects(); i++) {
// Pull down and parse the value from Mongo
rapidjson::Document resp_doc;
MongoResponseInterface *resp = mongo->load_document(\
inbound_message->get_object(i)->get_key());
if (resp) {
std::string mongo_resp_str = resp->get_value();
main_logging->debug("Document loaded from Mongo");
main_logging->debug(mongo_resp_str);
resp_doc.Parse(mongo_resp_str.c_str());
// Create a new Obj3 and add to the return list
ObjectInterface *resp_obj = objfactory.build_object(resp_doc);
response_message->add_object(resp_obj);
delete resp;
} else {
main_logging->error("Document not found in Mongo");
response_message->set_error_code(NOT_FOUND);
new_error_message = "Object not Found";
response_message->set_error_message(new_error_message);
}
}
// Object Query
} else if (inbound_message->get_msg_type() == OBJ_QUERY) {
main_logging->info("Processing Object Batch Query Message");
batch_query(inbound_message, response_message, mongo);
// Object Delete
} else if (inbound_message->get_msg_type() == OBJ_DEL) {
main_logging->info("Processing Object Deletion Message");
for (int i = 0; i < inbound_message->num_objects(); i++) {
ObjectInterface *resp_element = objfactory.build_object();
resp_element->set_key(\
inbound_message->get_object(i)->get_key());
mongo->delete_document(\
inbound_message->get_object(i)->get_key());
response_message->add_object(resp_element);
}
// Ping
} else if (inbound_message->get_msg_type() == PING) {
main_logging->info("Ping Message Recieved");
// Kill
} else if (inbound_message->get_msg_type() == KILL) {
main_logging->info("Shutting Down");
shutdown_needed = true;
// Invalid Message Type
} else {
response_message->set_error_code(BAD_MSG_TYPE_ERROR);
new_error_message = "Unknown Message Type";
response_message->set_error_message(new_error_message);
}
// Exception during processing
} catch (std::exception& e) {
main_logging->error("Exception encountered during Processing");
main_logging->error(e.what());
response_message->set_error_code(PROCESSING_ERROR);
new_error_message.assign(e.what());
response_message->set_error_message(new_error_message);
}
response_message->set_msg_type(inbound_message->get_msg_type());
}
// Convert the response object to a message
main_logging->debug("Building Response");
std::string application_response;
response_message->to_msg_string(application_response);
// Send the response via ZMQ
main_logging->info("Sending Response");
main_logging->info(application_response);
zmqi->send(application_response);
// Cleanup
if (response_message) {
delete response_message;
response_message = NULL;
}
if (inbound_message) {
delete inbound_message;
inbound_message = NULL;
}
// If we recieved a shutdown message, then we cleanup and exit
if (shutdown_needed) {shutdown(); exit(1);}
}
return 0;
}
int SettingRegistry::loadJSON(std::string filename, rapidjson::Document& json_document)
{
FILE* f = fopen(filename.c_str(), "rb");
if (!f)
{
cura::logError("Couldn't open JSON file.\n");
return 1;
}
char read_buffer[4096];
rapidjson::FileReadStream reader_stream(f, read_buffer, sizeof(read_buffer));
json_document.ParseStream(reader_stream);
fclose(f);
if (json_document.HasParseError())
{
cura::logError("Error parsing JSON(offset %u): %s\n", (unsigned)json_document.GetErrorOffset(), GetParseError_En(json_document.GetParseError()));
return 2;
}
return 0;
}