int janssonmod_array_size(struct sip_msg* msg, char* path_in, char* src_in, char* dst)
{
str src_s;
str path_s;
pv_spec_t *dst_pv;
pv_value_t dst_val;
if (fixup_get_svalue(msg, (gparam_p)src_in, &src_s) != 0) {
ERR("cannot get json string value\n");
return -1;
}
if (fixup_get_svalue(msg, (gparam_p)path_in, &path_s) != 0) {
ERR("cannot get path string value\n");
return -1;
}
dst_pv = (pv_spec_t *)dst;
json_t* json = NULL;
json_error_t parsing_error;
json = json_loads(src_s.s, JSON_REJECT_DUPLICATES, &parsing_error);
if(!json) {
ERR("json error at line %d: %s\n",
parsing_error.line, parsing_error.text);
goto fail;
}
char* path = path_s.s;
json_t* v = json_path_get(json, path);
if(!v) {
ERR("failed to find %s in json\n", path);
goto fail;
}
if(!json_is_array(v)) {
ERR("value at %s is not an array\n", path);
goto fail;
}
int size = json_array_size(v);
dst_val.ri = size;
dst_val.flags = PV_TYPE_INT|PV_VAL_INT;
dst_pv->setf(msg, &dst_pv->pvp, (int)EQ_T, &dst_val);
json_decref(json);
return 1;
fail:
json_decref(json);
return -1;
}
int janssonmod_get(struct sip_msg* msg, char* path_in, char* src_in, char* dst)
{
str src_s;
str path_s;
pv_spec_t *dst_pv;
pv_value_t dst_val;
if (fixup_get_svalue(msg, (gparam_p)src_in, &src_s) != 0) {
ERR("cannot get json string value\n");
return -1;
}
if (fixup_get_svalue(msg, (gparam_p)path_in, &path_s) != 0) {
ERR("cannot get path string value\n");
return -1;
}
dst_pv = (pv_spec_t *)dst;
json_t* json = NULL;
json_error_t parsing_error;
json = json_loads(src_s.s, JSON_REJECT_DUPLICATES, &parsing_error);
if(!json) {
ERR("failed to parse: %.*s\n", src_s.len, src_s.s);
ERR("json error at line %d: %s\n",
parsing_error.line, parsing_error.text);
goto fail;
}
char* path = path_s.s;
json_t* v = json_path_get(json, path);
if(!v) {
goto fail;
}
char* freeme = NULL;
if(jansson_to_val(&dst_val, &freeme, v)<0) goto fail;
dst_pv->setf(msg, &dst_pv->pvp, (int)EQ_T, &dst_val);
if(freeme!=NULL) {
free(freeme);
}
json_decref(json);
return 1;
fail:
json_decref(json);
return -1;
}
esdm_config_backend_t* esdm_config_get_metadata_coordinator(esdm_instance_t* esdm)
{
DEBUG_ENTER;
json_t *root = (json_t*) esdm->config->json;
json_t *elem = json_path_get(root, "$.esdm.metadata.type");
DEBUG("json_path_get (metadata backend) => %p -> %s\n", elem, json_string_value(elem));
#ifndef NDEBUG
print_json(elem);
#endif
esdm_config_backend_t *config_backend = (esdm_config_backend_t*) malloc(sizeof(esdm_config_backend_t));
config_backend->type = json_string_value(elem);
config_backend->esdm = root;
config_backend->backend = json_path_get(root, "$.esdm.metadata");
elem = json_object_get(config_backend->backend, "id");
config_backend->id = json_string_value(elem);
elem = json_object_get(config_backend->backend, "target");
config_backend->target = json_string_value(elem);
elem = json_object_get(config_backend->backend, "accessibility");
if (elem != NULL){
const char * str = json_string_value(elem);
if (strcasecmp(str, "global") == 0){
config_backend->data_accessibility = ESDM_ACCESSIBILITY_GLOBAL;
}else if (strcasecmp(str, "local") == 0){
config_backend->data_accessibility = ESDM_ACCESSIBILITY_NODELOCAL;
}else{
ESDM_ERROR("Unknown accessibility!");
}
} else
config_backend->data_accessibility = ESDM_ACCESSIBILITY_GLOBAL;
return config_backend;
}
void BEJSON::json_path_query ( const std::string& json_path, fmx::Data& results ) {
json_t * node = json_path_get ( document, json_path.c_str() );
if ( node ) {
std::string string_result;
switch ( json_typeof ( node ) ) {
case JSON_OBJECT:
case JSON_ARRAY:
string_result = (char *)json_dumps ( node, 0 );
SetResult ( string_result, results );
break;
case JSON_STRING:
string_result = (char *)json_string_value ( node );
SetResult ( string_result, results );
break;
case JSON_INTEGER:
case JSON_REAL:
string_result = (char *)json_number_value_as_string ( node );
SetResult ( string_result, results );
break;
case JSON_TRUE:
SetResult ( true, results );
break;
case JSON_FALSE:
SetResult ( false, results );
break;
case JSON_NULL:
default:
break;
}
} else {
throw BEJSON_Exception ( kBE_JSON_JSONPathDoesNotExistError );
}
} // json_path_query
int janssonmod_get_helper(sip_msg_t* msg, str *path_s, str *src_s, pv_spec_t *dst_pv)
{
pv_value_t dst_val;
json_t* json = NULL;
json_error_t parsing_error;
json = json_loads(src_s->s, JSON_REJECT_DUPLICATES, &parsing_error);
if(!json) {
ERR("failed to parse: %.*s\n", src_s->len, src_s->s);
ERR("json error at line %d: %s\n",
parsing_error.line, parsing_error.text);
goto fail;
}
char* path = path_s->s;
json_t* v = json_path_get(json, path);
if(!v) {
goto fail;
}
char* freeme = NULL;
if(jansson_to_val(&dst_val, &freeme, v)<0) goto fail;
dst_pv->setf(msg, &dst_pv->pvp, (int)EQ_T, &dst_val);
if(freeme!=NULL) {
free(freeme);
}
json_decref(json);
return 1;
fail:
json_decref(json);
return -1;
}
/**
* Fetches backends
*
*
*/
esdm_config_backends_t* esdm_config_get_backends(esdm_instance_t* esdm)
{
ESDM_DEBUG(__func__);
json_t *root = (json_t*) esdm->config->json;
// fetch configured backends
json_t *element = json_path_get(root, "$.esdm.backends");
esdm_config_backends_t* config_backends = (esdm_config_backends_t*) malloc(sizeof(esdm_config_backends_t));
if (element)
{
if (json_typeof(element) == JSON_ARRAY)
{
// Element is array, therefor may contain valid backend configurations
size_t size = json_array_size(element);
esdm_config_backend_t* backends;
backends = (esdm_config_backend_t*) malloc(sizeof(esdm_config_backend_t)*size);
//printf("JSON Array of %ld element%s:\n", size, json_plural(size));
size_t i, j;
for (i = 0; i < size; i++) {
//print_json_aux(json_array_get(element, i), 0);
json_t *backend = json_array_get(element, i);
json_t *elem = NULL;
elem = json_object_get(backend, "type");
backends[i].type = json_string_value(elem);
elem = json_object_get(backend, "id");
backends[i].id = json_string_value(elem);
for (j = 0; j < i; j++) {
if(strcmp(backends[i].id, backends[j].id) == 0){
printf("ERROR two backends with the same ID found: %s\n", backends[i].id);
ESDM_ERROR("Aborting!");
}
}
elem = json_object_get(backend, "target");
backends[i].target = json_string_value(elem);
backends[i].performance_model = json_object_get(backend, "performance-model");
DEBUG("type=%s id = %s target=%s\n", backends[i].type,
backends[i].id,
backends[i].target);
elem = json_object_get(backend, "max-threads-per-node");
if (elem == NULL){
backends[i].max_threads_per_node = 0;
}else{
backends[i].max_threads_per_node = json_integer_value(elem);
}
elem = json_object_get(backend, "max-global-threads");
if (elem == NULL){
backends[i].max_global_threads = 0;
}else{
backends[i].max_global_threads = json_integer_value(elem);
}
elem = json_object_get(backend, "accessibility");
if (elem != NULL){
const char * str = json_string_value(elem);
if (strcasecmp(str, "global") == 0){
backends[i].data_accessibility = ESDM_ACCESSIBILITY_GLOBAL;
}else if (strcasecmp(str, "local") == 0){
backends[i].data_accessibility = ESDM_ACCESSIBILITY_NODELOCAL;
}else{
ESDM_ERROR("Unknown accessibility!");
}
} else
backends[i].data_accessibility = ESDM_ACCESSIBILITY_GLOBAL;
elem = json_object_get(backend, "max-fragment-size");
if (elem == NULL){
backends[i].max_fragment_size = 10*1024*1024;
}else{
backends[i].max_fragment_size = json_integer_value(elem);
}
backends[i].esdm = root;
backends[i].backend = backend;
}
config_backends->count = size;
config_backends->backends = backends;
}
} else {
ESDM_ERROR("Invalid configuration! /esdm/backends is not an array.");
}
return config_backends;
}
std::vector<std::unique_ptr<model::Game>>
JSONGameListParser::parseGameList(std::basic_istream<gkbyte_t> & is)
{
json_t * root = nullptr;
json_error_t error;
std::vector<std::unique_ptr<model::Game>> games;
{
std::string jsonTree = utils::String::createFromStream(is);
root = json_loads(jsonTree.c_str(), 0, &error);
}
if(root)
{
json_t * gamesList = json_path_get(root, this->data->gamesListPath.c_str());
if(json_is_array(gamesList))
{
for(size_t i = 0; i < json_array_size(gamesList); i++)
{
json_t * gameNode = json_array_get(gamesList, i);
std::unique_ptr<model::GenericGame> game = std::make_unique<model::GenericGame>();
game->setId(json_string_value(json_path_get(gameNode, this->data->gameIdPath.c_str())));
game->setName(json_string_value(json_path_get(gameNode, this->data->gameNamePath.c_str())));
if(!this->data->gameDescriptionPath.empty())
{
game->setDescription(json_string_value(json_path_get(gameNode, this->data->gameDescriptionPath.c_str())));
}
if(!this->data->gameHomepagePath.empty())
{
game->setHomepage(json_string_value(json_path_get(gameNode, this->data->gameHomepagePath.c_str())));
}
json_t * gamePlatforms = json_path_get(gameNode, this->data->gamePlatformsPath.c_str());
std::set<model::Platform> platforms;
for(size_t p = 0; p < json_array_size(gamePlatforms); p++)
{
std::string platform = json_string_value(json_path_get(json_array_get(gamePlatforms, p), "$"));
if(platform == this->data->platformWin32Id)
{
platforms.insert(model::Platform::WIN_32);
}
else if(platform == this->data->platformMac32Id)
{
platforms.insert(model::Platform::MAC_32);
}
else if(platform == this->data->platformLin32Id)
{
platforms.insert(model::Platform::LIN_32);
}
else if(platform == this->data->platformLin64Id)
{
platforms.insert(model::Platform::LIN_64);
}
}
game->setPlatforms(std::move(platforms));
games.push_back(std::move(game));
}
}
}
json_decref(root);
return games;
}
