struct netloc_dt_lookup_table* netloc_dt_lookup_table_t_json_decode(json_t *json_lt,
void * (*func)(const char *key, json_t* json_obj))
{
struct netloc_dt_lookup_table *table = NULL;
const char * key = NULL;
json_t * value = NULL;
table = calloc(1, sizeof(*table));
netloc_lookup_table_init(table, json_object_size(json_lt), 0);
json_object_foreach(json_lt, key, value) {
netloc_lookup_table_append(table, key, func(key, value));
}
int netloc_dc_append_path(netloc_data_collection_handle_t *handle,
const char * src_node_id,
const char * dest_node_id,
int num_edges, netloc_edge_t **edges,
bool is_logical)
{
int i;
netloc_node_t *node = NULL;
int *edge_ids = NULL;
unsigned long key_int;
/*
* Find the source Node
*/
SUPPORT_CONVERT_ADDR_TO_INT(src_node_id, handle->network->network_type, key_int);
node = netloc_lookup_table_access_with_int( handle->node_list, src_node_id, key_int );
if( NULL == node ) {
fprintf(stderr, "Error: node not found in the list (id = %s)\n", src_node_id);
return NETLOC_ERROR;
}
/*
* Copy the edge id's
* Note: The 'path' storage is not a set of edge pointers, but edge ids.
* It is assumed that the user will push paths into the data collection, but
* not have to retrieve that path from the dc_handle.
*/
edge_ids = (int*)malloc(sizeof(int)* (num_edges+1));
if( NULL == edge_ids ) {
return NETLOC_ERROR;
}
for(i = 0; i < num_edges; ++i) {
if( NULL == edges[i] ) {
edge_ids[i] = NETLOC_EDGE_UID_INVALID;
} else {
edge_ids[i] = edges[i]->edge_uid;
}
}
// Null terminated array
edge_ids[num_edges] = NETLOC_EDGE_UID_NULL;
/*
* Add the entry to the hash
*/
if( is_logical ) {
if( NULL == node->logical_paths ) {
node->logical_paths = calloc(1, sizeof(*node->logical_paths));
netloc_lookup_table_init(node->logical_paths, 1, 0);
node->num_log_paths = 0;
}
node->num_log_paths += 1;
netloc_lookup_table_append( node->logical_paths, dest_node_id, edge_ids);
} else {
if( NULL == node->physical_paths ) {
node->physical_paths = calloc(1, sizeof(*node->physical_paths));
netloc_lookup_table_init(node->physical_paths, 1, 0);
node->num_log_paths = 0;
}
node->num_log_paths += 1;
netloc_lookup_table_append( node->physical_paths, dest_node_id, edge_ids);
}
return NETLOC_SUCCESS;
}
int netloc_dc_append_edge_to_node(netloc_data_collection_handle_t *handle, netloc_node_t *node, netloc_edge_t *edge)
{
char *key = NULL;
netloc_edge_t *found_edge = NULL;
netloc_node_t *found_node = NULL;
unsigned long key_int;
bool is_cached = false;
/*
* Setup the table for the first edge
*/
if( NULL == handle->edges ) {
handle->edges = calloc(1, sizeof(*handle->edges));
netloc_lookup_table_init(handle->edges, 1, 0);
}
/*
* Setup the table for the first node
*/
if(NULL == handle->node_list) {
handle->node_list = calloc(1, sizeof(*handle->node_list));
netloc_lookup_table_init(handle->node_list, 1, 0);
}
/*
* Check to see if we have seen this edge before
*/
asprintf(&key, "%d", edge->edge_uid);
found_edge = (netloc_edge_t*)netloc_lookup_table_access(handle->edges, key);
free(key);
key = NULL;
// JJH: Should we be checking the contents of the edge, not just the key?
/*
* If not add it to the edges lookup table
*/
if( NULL == found_edge ) {
found_edge = netloc_dt_edge_t_dup(edge);
asprintf(&key, "%d", found_edge->edge_uid);
netloc_lookup_table_append(handle->edges, key, found_edge);
free(key);
key = NULL;
}
/*
* Update the edge links
* if the node endpoint is not in the list, then add a stub
*/
if( NULL == edge->src_node_id ) {
return NETLOC_ERROR_NOT_FOUND;
}
SUPPORT_CONVERT_ADDR_TO_INT(edge->src_node_id, handle->network->network_type, key_int);
asprintf(&key, "%s", edge->src_node_id);
found_node = netloc_lookup_table_access_with_int(handle->node_list, key, key_int);
if( NULL == found_node ) {
found_node = netloc_dt_node_t_construct();
found_node->physical_id = strdup(edge->src_node_id);
found_node->physical_id_int = key_int;
found_node->node_type = NETLOC_NODE_TYPE_INVALID;
netloc_lookup_table_append_with_int(handle->node_list, key, key_int, found_node);
} else {
is_cached = true;
}
found_edge->src_node = found_node;
free(key);
key = NULL;
if( NULL == edge->dest_node_id ) {
return NETLOC_ERROR_NOT_FOUND;
}
asprintf(&key, "%s", edge->dest_node_id);
SUPPORT_CONVERT_ADDR_TO_INT(edge->dest_node_id, handle->network->network_type, key_int);
found_node = netloc_lookup_table_access_with_int(handle->node_list, key, key_int);
if( NULL == found_node ) {
found_node = netloc_dt_node_t_construct();
found_node->physical_id = strdup(edge->dest_node_id);
found_node->physical_id_int = key_int;
found_node->node_type = NETLOC_NODE_TYPE_INVALID;
netloc_lookup_table_append_with_int(handle->node_list, key, key_int, found_node);
}
found_edge->dest_node = found_node;
free(key);
key = NULL;
/*
* Add the edge index to the node passed to us
*/
node->num_edge_ids++;
node->edge_ids = (int*)realloc(node->edge_ids, sizeof(int) * node->num_edge_ids);
node->edge_ids[node->num_edge_ids -1] = found_edge->edge_uid;
node->num_edges++;
node->edges = (netloc_edge_t**)realloc(node->edges, sizeof(netloc_edge_t*) * node->num_edges);
node->edges[node->num_edges -1] = found_edge;
/*
* Update the cached version of this node
*/
if( is_cached ) {
json_object_del(handle->node_data_acc, node->physical_id);
json_object_set_new(handle->node_data_acc, node->physical_id, netloc_dt_node_t_json_encode(node));
}
return NETLOC_SUCCESS;
}