--- /dev/null
+/*
+==================================================================================
+
+ Copyright (c) 2018-2019 AT&T Intellectual Property.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+==================================================================================
+*/
+/*
+ Author : Ashwin Sridharan
+
+
+*/
+
+#include <json_handler.hpp>
+#include <cstdio>
+
+TrieNode::TrieNode(int val): val_type(-1){
+ _id.tag = DataContainer::Types::integer;
+ _id.value.i = val;
+}
+
+TrieNode::TrieNode( std::string val) : val_type(-1){
+ _id.tag = DataContainer::Types::str;
+ _id.value.s.assign(val);
+}
+
+void TrieNode::set_value(const char * val){
+ _val.tag = DataContainer::Types::str;
+ _val.value.s.assign(val);
+}
+
+
+void TrieNode::set_value(bool val){
+ _val.tag = DataContainer::Types::boolean;
+ _val.value.b = val;
+
+}
+
+void TrieNode::set_value(int val){
+ _val.tag = DataContainer::Types::integer;
+ _val.value.i = val;
+ //std::cout <<"Assigned integer " << val << std::endl;
+
+
+}
+
+void TrieNode::set_value(unsigned int val){
+ _val.tag = DataContainer::Types::uinteger;
+ _val.value.ui = val;
+
+}
+
+void TrieNode::set_value( long int val){
+ _val.tag = DataContainer::Types::big_integer;
+ _val.value.l = val;
+}
+
+void TrieNode::set_value(unsigned long int val){
+ _val.tag = DataContainer::Types::ubig_integer;
+ _val.value.ul = val;
+}
+
+void TrieNode::set_value(double val){
+ _val.tag = DataContainer::Types::real;
+ _val.value.f = val;
+
+}
+
+
+void TrieNode::set_value(std::string val){
+ _val.tag = DataContainer::Types::str;
+ _val.value.s.assign(val);
+}
+
+void TrieNode::set_value(const char * c, size_t len){
+ _val.tag = DataContainer::Types::str;
+ _val.value.s.assign(c, len);
+}
+
+void TrieNode::add_child(TrieNode * node){
+ _children.push_back(node);
+};
+
+
+
+void TrieNode::print_id(void){
+ switch(_id.tag){
+
+ case DataContainer::Types::integer :
+ std::cout <<"Type = " << _id.tag << " Value = " << _id.value.i << std::endl;
+ break;
+ case DataContainer::Types::str :
+ std::cout <<"Type = " << _id.tag << " Value = " << _id.value.s << std::endl;
+ break;
+ default:
+ std::cerr<< "Error ! ID not set or unknown type " << _id.tag;
+ }
+};
+
+void TrieNode::print_value(void){
+ switch(_val.tag){
+
+ case DataContainer::Types::boolean :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.b << std::endl;
+ break;
+ case DataContainer::Types::integer :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.i << std::endl;
+ break;
+ case DataContainer::Types::uinteger :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.ui << std::endl;
+ break;
+ case DataContainer::Types::big_integer :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.l << std::endl;
+ break;
+ case DataContainer::Types::ubig_integer :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.ul << std::endl;
+ break;
+ case DataContainer::Types::real :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.f << std::endl;
+ break;
+ case DataContainer::Types::str :
+ std::cout <<"Type = " << _val.tag << " Value = " << _val.value.s << std::endl;
+ break;
+ default:
+ std::cerr<< "Error ! Value not set or unknown type " << _val.tag;
+ }
+};
+
+
+jsonHandler::jsonHandler(void):_is_root(false), _is_schema(false), _is_buffer(false){
+
+};
+
+
+
+
+void jsonHandler::load_file(std::string input_file, std::string & contents ){
+
+ std::FILE *fp ;
+ try{
+ fp = std::fopen(input_file.c_str(), "rb");
+ }
+ catch(std::exception &e){
+ std::string error_string = "Error opening input schema file " + input_file;
+ throw std::runtime_error(error_string);
+ }
+
+ if (fp){
+ std::fseek(fp, 0, SEEK_END);
+ contents.resize(std::ftell(fp));
+ std::rewind(fp);
+ std::fread(&contents[0], 1, contents.size(), fp);
+ std::fclose(fp);
+ }
+
+ else{
+ std::string error_string = "Error opening input file " + input_file;
+ throw std::runtime_error(error_string);
+ }
+
+}
+
+
+
+void jsonHandler::load_schema(std::string input_file){
+
+ load_file(input_file, _contents);
+ Document _doc;
+ if (_doc.Parse(_contents.c_str()).HasParseError()){
+ std::string error_string = input_file + " is invalid JSON" ;
+ throw std::runtime_error(error_string);
+ }
+
+ _ref_schema_doc= std::make_unique<SchemaDocument>(_doc);
+ _is_schema = true;
+
+
+}
+
+void jsonHandler::load_schema(std::string input_file, TrieNode * root){
+
+ load_file(input_file, _contents);
+ std::string response;
+ Document _doc;
+ if (_doc.Parse(_contents.c_str()).HasParseError()){
+ std::string error_string = input_file + " is invalid JSON" ;
+ throw std::runtime_error(error_string);
+ }
+
+ // Get message schema
+ bool res;
+ Value _schema_root;
+ Value &_root = _doc;
+ res = find_member(_root, response, root, _schema_root);
+ if (res == false){
+ throw std::runtime_error(response);
+ }
+
+ _ref_schema_doc= std::make_unique<SchemaDocument>(_schema_root);
+ _is_schema = true;
+
+}
+
+void jsonHandler::load_buffer(std::string input_file){
+
+ load_file(input_file, _buffer);
+ Document _doc;
+ if (_doc.Parse(_buffer.c_str()).HasParseError()){
+ std::string error_string = input_file + " is invalid JSON" ;
+ throw std::runtime_error(error_string);
+ }
+ _is_buffer = true;
+
+}
+
+void jsonHandler::load_buffer(std::string input_file, TrieNode * root){
+
+ load_file(input_file, _buffer);
+ Document _doc;
+ std::string response;
+
+ if (_doc.Parse(_buffer.c_str()).HasParseError()){
+ std::string error_string = input_file + " is invalid JSON" ;
+ throw std::runtime_error(error_string);
+ }
+
+ bool res;
+ Value _buffer_root;
+ res = find_member(_doc, response, root, _buffer_root);
+ if(res == false){
+ throw std::runtime_error(response);
+ }
+
+ StringBuffer out_buffer;
+ Writer<StringBuffer> writer(out_buffer);
+ _buffer_root.Accept(writer);
+ _buffer.assign(out_buffer.GetString(), out_buffer.GetLength());
+ _is_buffer = true;
+}
+
+
+std::string jsonHandler::get_buffer(void){
+ std::string response;
+ if (_is_buffer){
+ response.assign(_buffer);
+ }
+ else{
+ response = "";
+ }
+
+ return response;
+}
+
+
+
+
+
+
+bool jsonHandler::find_member(const std::string schema, std::string & response, TrieNode * root, Value & TargetVal){
+
+ Document doc;
+ std::string contents(schema);
+
+ if(doc.Parse(contents.c_str()).HasParseError()){
+ response.assign("Error Parsing JSON File");
+ return false;
+ }
+
+ return find_member(doc, response, root, TargetVal);
+ return true;
+};
+
+
+bool jsonHandler::find_member(Value & doc_root, std::string & response, TrieNode * root, Value & TargetVal){
+
+ if (!root){
+ response.assign("Null Trie root node");
+ return false;
+ }
+ //std::cout <<"LOoking for schema root" << std::endl;
+
+ Value & json_node = doc_root;
+ TrieNode * trie_node = root;
+ Value::MemberIterator itr;
+
+ while(1){
+
+ DataContainer const * d = trie_node->get_id();
+ if (! d){
+ response.assign("Error could not find any id for trie node ");
+ return false;
+ }
+
+ if (d->tag == DataContainer::Types::integer && json_node.IsArray()){
+ if (json_node.Size() < d->value.i){
+ response.assign("Error json array size ");
+ response += std::to_string(json_node.Size()) + " is smaller than trie node index " + std::to_string( d->value.i);
+ return false;
+ }
+
+ if (trie_node->is_child()){
+ response.assign("Error child trie points to an array ? ");
+ return false;
+ }
+
+ trie_node = trie_node->get_children()[0];
+ json_node = json_node[d->value.i];
+ }
+ else if (d->tag == DataContainer::Types::str && json_node.IsObject()){
+
+ itr = json_node.FindMember(d->value.s.c_str());
+ if (itr == json_node.MemberEnd()){
+ response.assign("Error ! Could not find key = ");
+ response += d->value.s;
+ return false;
+ }
+ if (trie_node->is_child()){
+ // reached end of trie
+ if (itr->value.IsObject()){
+ TargetVal = itr->value.GetObject();
+ //std::cout <<"Reached root = " << itr->name.GetString() << std::endl;
+ }
+ else if (itr->value.IsArray()){
+ TargetVal = itr->value.GetArray();
+ }
+ else{
+ response.assign("Error ! JSON node selected must be object or array in current version");
+ std::cerr << response << std::endl;
+ return false;
+ }
+ break;
+ }
+ else{
+ trie_node = trie_node->get_children()[0];
+ trie_node->print_id();
+
+ if (itr->value.IsObject()){
+ json_node = itr->value.GetObject();
+ }
+ else if (itr->value.IsArray()){
+ json_node = itr->value.GetArray();
+ }
+ else{
+ std::string error_string= " Path must be an object or array";
+ response.assign(error_string);
+ return false;
+ }
+ }
+ }
+ else{
+ std::string error_string = "Mismatch when setting root : Trie node is of type = " + std::to_string (d->tag) + " and json node is of type = " + std::to_string(json_node.GetType());
+ response.assign(error_string);
+ return false;
+ }
+
+ }
+
+ return true;
+
+}
+
+bool jsonHandler::is_valid(const char *message, int message_length, std::string & response){
+
+ Document doc;
+ if (! _is_schema){
+ return false;
+ }
+
+ SchemaValidator validator(*(_ref_schema_doc.get()));
+
+ // ensure message has terminator by translating to string ?
+ std::string message_s(message, message_length);
+
+
+ // validate json
+ if (doc.Parse(message_s.c_str()).HasParseError()){
+
+ // return error message
+ std::string failed_message = "\"message\": \"Invalid JSON\"";
+ response.assign( failed_message );
+ return false;
+ }
+
+
+ // Validate against our JSON input schema
+ if (!doc.Accept(validator)){
+
+ StringBuffer sb;
+ validator.GetInvalidSchemaPointer().StringifyUriFragment(sb);
+ std::string failed_message = std::string("\"message\": \"Schema Violation:") + std::string(sb.GetString());
+ failed_message += std::string(" Invalid keyword :") + std::string(validator.GetInvalidSchemaKeyword()) + " \"";
+ response.assign(failed_message);
+ return false;
+
+ }
+ response.assign("SUCCESS");
+ return true;
+
+
+}
+
+
+
+// should be thread safe since it can be expected to be called from multiple threads
+// only static external variable referenced is the schema (which should be read-only and hence ok ?)
+
+// Returns 0 if success
+// -1 if invalid json
+// -2 if invalid schema (assuming schema provided)
+// -3 unknown key
+// -4 no buffer available
+
+int jsonHandler::get_values(const char *message, int message_length, std::string & response, TrieNode * root, std::vector<TrieNode *> & response_list){
+
+ Document doc;
+
+ // ensure message has terminator by translating to string ?
+ std::string message_s(message, message_length);
+
+ // validate json
+ if (doc.Parse(message_s.c_str()).HasParseError()){
+
+ // return error message
+ response.assign("Invalid JSON");
+ return -1;
+ }
+
+ // Validate against our JSON input schema
+ if ( _is_schema){
+ SchemaValidator validator(*(_ref_schema_doc.get()));
+
+ if (!doc.Accept(validator)){
+
+ StringBuffer sb;
+ validator.GetInvalidSchemaPointer().StringifyUriFragment(sb);
+ response = std::string("Schema Violation ") + std::string(sb.GetString()) ;
+ response += std::string(" Invalid keyword = ") + std::string(validator.GetInvalidSchemaKeyword()) + " \"";
+ return -2;
+ }
+
+ }
+
+ Value & doc_root = doc;
+ bool res = traverse_doc(doc_root, root, true, response, response_list);
+ if (!res){
+ return -3;
+ }
+
+ response.assign("SUCCESS");
+ return 0;
+}
+
+
+int jsonHandler::get_values( std::string & response, TrieNode * root, std::vector<TrieNode *> & response_list){
+ int res;
+ if (_is_buffer){
+ Document _doc;
+ _doc.Parse(_buffer.c_str());
+ Value & _buffer_root = _doc;
+
+ res = traverse_doc(_buffer_root, root, true, response, response_list);
+ return res;
+ }
+ else{
+ response = "Error ! No buffer loaded in json object for get";
+ return -4;
+ }
+}
+
+
+// If in get mode, return all values we can get
+// If in set mode, return false if we cannot set a value
+bool jsonHandler::traverse_doc(Value & json_node, TrieNode * trie_node, bool get, std::string & response, std::vector<TrieNode* > & response_list ){
+
+ if (!trie_node){
+ response.assign(" Null Trie node ");
+ return false;
+ }
+
+ bool res;
+
+ DataContainer const * d = trie_node->get_id();
+ if (! d){
+ response.assign(" Error could not find any id for trie node");
+ return false;
+ }
+
+ Value::MemberIterator itr;
+
+
+ if (d->tag == DataContainer::Types::integer && json_node.IsArray()){
+ if (json_node.Size() < d->value.i){
+ response = "Error json array size " + std::to_string( json_node.Size()) + " is smaller than trie node index " + std::to_string( d->value.i);
+ return false;
+ }
+
+ if (trie_node->is_child()){
+ response.assign("Error child trie points to an array ? ");
+ return false;
+ }
+
+ for (auto & e: trie_node->get_children()){
+ res = traverse_doc(json_node[d->value.i], e, get, response, response_list);
+ if (!res && ! get){
+ // if not in get mode and we hit a not found
+ // don't go any further, else move to next ...
+ return res;
+ }
+ }
+ }
+
+ else if (d->tag == DataContainer::Types::str && json_node.IsObject()){
+ itr = json_node.FindMember(d->value.s.c_str());
+
+ if (itr == json_node.MemberEnd()){
+ response = "Error ! Could not find key " + d->value.s;
+ return false;
+ }
+
+ if (trie_node->is_child()){
+ // end of the line : do we get or set values ?
+ bool is_set = false;
+ if (get){
+ if (itr->value.IsBool()){
+ trie_node->set_value(itr->value.GetBool());
+ is_set = true;
+ }
+ else if (itr->value.IsInt()){
+ trie_node->set_value(itr->value.GetInt());
+ is_set = true;
+ }
+ else if(itr->value.IsUint()){
+ trie_node->set_value(static_cast<unsigned int>(itr->value.GetUint()));
+ is_set = true;
+ }
+ else if(itr->value.IsUint64()){
+ trie_node->set_value(static_cast<unsigned long int>(itr->value.GetUint64()));
+ is_set = true;
+ }
+ else if (itr->value.IsInt64()){
+ trie_node->set_value(static_cast<long int>(itr->value.GetInt64()));
+ is_set = true;
+ }
+ else if ( itr->value.IsDouble()){
+ trie_node->set_value(itr->value.GetDouble());
+ is_set = true;
+ }
+ else if ( itr->value.IsString()){
+ trie_node->set_value(itr->value.GetString(), itr->value.GetStringLength());
+ is_set = true;
+ }
+ else{
+ response = " json node corresponding to child node key must of type bool, int or string. Is of type = " + std::to_string(itr->value.GetType());
+ return false;
+ }
+
+ if (is_set){
+ response_list.push_back(trie_node);
+ }
+
+ //std::cout <<"Set value of child node with key = " << d->value.s.c_str() << " Type = " << trie_node->get_type() << std::endl;
+
+ }
+ else{
+ DataContainer const * d_val = trie_node->get_value();
+ if (d_val->tag == DataContainer::Types::boolean){
+ itr->value.SetBool(d_val->value.b);
+ }
+ else if (d_val->tag == DataContainer::Types::integer){
+ itr->value.SetInt(d_val->value.i);
+
+ }
+ else if (d_val->tag == DataContainer::Types::uinteger){
+ itr->value.SetUint(d_val->value.ui);
+
+ }
+ else if (d_val->tag == DataContainer::Types::big_integer){
+ itr->value.SetInt64(d_val->value.l);
+ }
+ else if (d_val->tag == DataContainer::Types::ubig_integer){
+ itr->value.SetUint64(d_val->value.ul);
+ }
+ else if (d_val->tag == DataContainer::Types::real){
+ itr->value.SetDouble(d_val->value.f);
+ }
+ else if (d_val->tag == DataContainer::Types::str){
+ itr->value.SetString(d_val->value.s.c_str(), d_val->value.s.length());
+ }
+ else{
+ response = " unknown type for child node value = " + std::to_string(d_val->tag) + " cannot set json node key = " + d->value.s;
+ return false;
+ }
+ }
+ return true;
+ }
+ else{
+ for (auto & e: trie_node->get_children()){
+ res = traverse_doc(itr->value, e, get, response, response_list);
+ if(res == false && ! get){
+ return false;
+ }
+ }
+ }
+ }
+
+ else{
+ response = "Mismatch : Trie node is of type = " + std::to_string(d->tag) + " while json node is of type = " + std::to_string( json_node.GetType());
+ return false;
+ }
+
+ return true;
+
+
+}
+
+
+int jsonHandler::set_values(const char * buffer, int len, std::string & response, std::vector<TrieNode *> root_nodes){
+
+ Document doc;
+ std::string message_s(buffer, len);
+
+ // validate json
+ if (doc.Parse(message_s.c_str()).HasParseError()){
+ // return error message
+ response.assign("Invalid JSON");
+ return -1;
+ }
+
+
+ Value & doc_root = doc;
+ // fake list to maintain signature for re-using traverse_doc
+ // since we don't return trie nodes when setting ...
+ std::vector<TrieNode *> fake_list;
+ for(auto const & e: root_nodes){
+ bool res = traverse_doc(doc_root, e, false, response, fake_list);
+ if (!res){
+ return -3;
+ }
+ }
+
+ StringBuffer out_buffer;
+ Writer<StringBuffer> writer(out_buffer);
+ doc_root.Accept(writer);
+ response.assign(out_buffer.GetString(), out_buffer.GetLength());
+ return 0;
+ }
+
+
+// wrapper if instead of providing buffer, we simply use stored json object and use it
+int jsonHandler::set_values(std::string & response, std::vector<TrieNode *> root_nodes){
+ if (_is_buffer){
+ std::vector<TrieNode *> fake_list;
+ Document _doc;
+ _doc.Parse(_buffer.c_str());
+ Value & _buffer_root = _doc;
+
+ for(auto const & e: root_nodes){
+ bool res = traverse_doc(_buffer_root, e, false, response, fake_list);
+ if (!res){
+ return -3;
+ }
+ }
+
+ StringBuffer out_buffer;
+ Writer<StringBuffer> writer(out_buffer);
+ _buffer_root.Accept(writer);
+ response.assign(out_buffer.GetString(), out_buffer.GetLength());
+ return 0;
+ }
+ else{
+ response = "Error ! " + std::string( __FILE__) + "," + std::to_string(__LINE__) + " : No buffer loaded in json object to set";
+ return -1;
+ }
+
+}
Code Review / ric-app / admin.git / blobdiff