int task_execute(oph_operator_struct * handle)
{
if (!handle || !handle->operator_handle) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_NULL_OPERATOR_HANDLE);
return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE;
}
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
logging(LOG_INFO, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_INFO_START);
int level = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->level;
char *func_ret = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_ret;
char *func_type = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_type;
char *name_filter = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->name_filter;
int limit = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->limit;
int id_dbms = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->id_dbms;
ophidiadb *oDB = &((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB;
char **objkeys = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys;
int objkeys_num = ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys_num;
if (oph_odb_read_ophidiadb_config_file(oDB)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to read OphidiaDB configuration\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_OPHIDIADB_CONFIGURATION_FILE_NO_CONTAINER);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
if (oph_odb_connect_to_ophidiadb(oDB)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to connect to OphidiaDB. Check access parameters.\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_OPHIDIADB_CONNECTION_ERROR_NO_CONTAINER);
oph_odb_disconnect_from_ophidiadb(&((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
oph_odb_dbms_instance dbms;
if (id_dbms == 0) {
if (oph_odb_stge_retrieve_first_dbmsinstance(oDB, &dbms)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve DBMS info\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_RETRIEVE_DBMS_ERROR, id_dbms);
oph_odb_disconnect_from_ophidiadb(&((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
} else {
if (oph_odb_stge_retrieve_dbmsinstance(oDB, id_dbms, &dbms)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve DBMS info\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_RETRIEVE_DBMS_ERROR, id_dbms);
oph_odb_disconnect_from_ophidiadb(&((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
}
oph_odb_disconnect_from_ophidiadb(&((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB);
int num_fields;
switch (level) {
case 5:
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+---------+\n");
printf("| %-35s | %-12s | %-45s | %-15s | %-7s |\n", "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY", "PRIMITIVE TYPE", "DBMS ID");
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+---------+\n");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
num_fields = 5;
char *keys[5] = { "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY", "PRIMITIVE TYPE", "DBMS ID" };
char *fieldtypes[5] = { "string", "string", "string", "string", "int" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, "Primitives List", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
break;
case 4:
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+\n");
printf("| %-35s | %-12s | %-45s | %-15s |\n", "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY", "PRIMITIVE TYPE");
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+\n");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
num_fields = 4;
char *keys[4] = { "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY", "PRIMITIVE TYPE" };
char *fieldtypes[4] = { "string", "string", "string", "string" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, "Primitives List", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
break;
case 3:
printf("+-------------------------------------+--------------+-----------------------------------------------+\n");
printf("| %-35s | %-12s | %-45s |\n", "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY");
printf("+-------------------------------------+--------------+-----------------------------------------------+\n");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
num_fields = 3;
char *keys[3] = { "PRIMITIVE NAME", "RETURN TYPE", "DYNAMIC LIBRARY" };
char *fieldtypes[3] = { "string", "string", "string" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, "Primitives List", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
break;
case 2:
printf("+-------------------------------------+--------------+\n");
printf("| %-35s | %-12s |\n", "PRIMITIVE NAME", "RETURN TYPE");
printf("+-------------------------------------+--------------+\n");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
num_fields = 2;
char *keys[2] = { "PRIMITIVE NAME", "RETURN TYPE" };
char *fieldtypes[2] = { "string", "string" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, "Primitives List", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
break;
case 1:
printf("+-------------------------------------+\n");
printf("| %-35s |\n", "PRIMITIVE NAME");
printf("+-------------------------------------+\n");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
num_fields = 1;
char *keys[1] = { "PRIMITIVE NAME" };
char *fieldtypes[1] = { "string" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, "Primitives List", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
break;
default:
pmesg(LOG_ERROR, __FILE__, __LINE__, "List level unrecognized\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_BAD_LEVEL);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_dc_setup_dbms(&(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server), dbms.io_server_type)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to initialize IO server.\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_IOPLUGIN_SETUP_ERROR, dbms.io_server_type);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (oph_dc_connect_to_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms, 0)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to connect to DBMS. Check access parameters.\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_CONNECT_DBMS_ERROR, dbms.id_dbms);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
oph_ioserver_result *primitives_list = NULL;
//retrieve primitives list
if (oph_dc_get_primitives(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms, name_filter, &primitives_list)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve primitives list\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_RETRIEVE_LIST_ERROR, dbms.id_dbms);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
int num_rows = 0;
//Empty set
if (!(num_rows = primitives_list->num_rows)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "No rows found by query\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_NO_ROWS_FOUND);
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
if (primitives_list->num_fields != 4) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Not enough fields found by query\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_NO_ROWS_FOUND);
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
oph_ioserver_row *curr_row = NULL;
if (oph_ioserver_fetch_row(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list, &curr_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to fetch row\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_ROW_ERROR);
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_DC_SERVER_ERROR;
}
//For each ROW
char tmp_ret[OPH_COMMON_BUFFER_LEN] = { '\0' }, tmp_type[OPH_COMMON_BUFFER_LEN] = {
'\0'};
int n;
int count_limit = 0;
while (curr_row->row) {
if (limit > 0 && count_limit >= limit)
break;
switch (level) {
case 5:
if (func_ret || func_type) {
if (func_ret) {
n = snprintf(tmp_ret, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[1][0] == '0') ? "array" : "number");
if (n <= 0)
break;
if (strncmp(tmp_ret, func_ret, OPH_COMMON_BUFFER_LEN) != 0)
break;
}
if (func_type) {
n = snprintf(tmp_type, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[3][0] == 'f') ? "simple" : "aggregate");
if (n <= 0)
break;
if (strncmp(tmp_type, func_type, OPH_COMMON_BUFFER_LEN) != 0)
break;
}
printf("| %-35s | %-12s | %-45s | %-15s | %7d |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2],
(curr_row->row[3][0] == 'f') ? "simple" : "aggregate", dbms.id_dbms);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char tmpbuf[20];
snprintf(tmpbuf, 20, "%d", dbms.id_dbms);
char *my_row[5] =
{ curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2], (curr_row->row[3][0] == 'f') ? "simple" : "aggregate",
tmpbuf
};
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
} else {
printf("| %-35s | %-12s | %-45s | %-15s | %7d |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2],
(curr_row->row[3][0] == 'f') ? "simple" : "aggregate", dbms.id_dbms);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char tmpbuf[20];
snprintf(tmpbuf, 20, "%d", dbms.id_dbms);
char *my_row[5] =
{ curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2], (curr_row->row[3][0] == 'f') ? "simple" : "aggregate",
tmpbuf
};
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
}
count_limit++;
break;
case 4:
if (func_ret || func_type) {
if (func_ret) {
n = snprintf(tmp_ret, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[1][0] == '0') ? "array" : "number");
if (n <= 0)
break;
if (strncmp(tmp_ret, func_ret, OPH_COMMON_BUFFER_LEN) != 0)
break;
}
if (func_type) {
n = snprintf(tmp_type, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[3][0] == 'f') ? "simple" : "aggregate");
if (n <= 0)
break;
if (strncmp(tmp_type, func_type, OPH_COMMON_BUFFER_LEN) != 0)
break;
}
printf("| %-35s | %-12s | %-45s | %-15s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2],
(curr_row->row[3][0] == 'f') ? "simple" : "aggregate");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[4] =
{ curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2], (curr_row->row[3][0] == 'f') ? "simple" : "aggregate" };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
} else {
printf("| %-35s | %-12s | %-45s | %-15s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2],
(curr_row->row[3][0] == 'f') ? "simple" : "aggregate");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[4] =
{ curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2], (curr_row->row[3][0] == 'f') ? "simple" : "aggregate" };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
}
count_limit++;
break;
case 3:
if (func_ret) {
n = snprintf(tmp_ret, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[1][0] == '0') ? "array" : "number");
if (n <= 0)
break;
if (strncmp(tmp_ret, func_ret, OPH_COMMON_BUFFER_LEN) != 0)
break;
printf("| %-35s | %-12s | %-45s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2]);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[3] = { curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2] };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
} else {
printf("| %-35s | %-12s | %-45s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2]);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[3] = { curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number", curr_row->row[2] };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
}
count_limit++;
break;
case 2:
if (func_ret) {
n = snprintf(tmp_ret, OPH_COMMON_BUFFER_LEN, "%s", (curr_row->row[1][0] == '0') ? "array" : "number");
if (n <= 0)
break;
if (strncmp(tmp_ret, func_ret, OPH_COMMON_BUFFER_LEN) != 0)
break;
printf("| %-35s | %-12s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[2] = { curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number" };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
} else {
printf("| %-35s | %-12s |\n", curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number");
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[2] = { curr_row->row[0], (curr_row->row[1][0] == '0') ? "array" : "number" };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
}
count_limit++;
break;
case 1:
printf("| %-35s |\n", curr_row->row[0]);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST)) {
char *my_row[1] = { curr_row->row[0] };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_LIST, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
count_limit++;
break;
default:
pmesg(LOG_ERROR, __FILE__, __LINE__, "List level unrecognized\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_BAD_LEVEL);
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_ioserver_fetch_row(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list, &curr_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to fetch row\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_ROW_ERROR);
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
return OPH_DC_SERVER_ERROR;
}
}
oph_ioserver_free_result(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, primitives_list);
oph_dc_disconnect_from_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server, &dbms);
oph_dc_cleanup_dbms(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server);
switch (level) {
case 5:
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+---------+\n");
break;
case 4:
printf("+-------------------------------------+--------------+-----------------------------------------------+-----------------+\n");
break;
case 3:
printf("+-------------------------------------+--------------+-----------------------------------------------+\n");
break;
case 2:
printf("+-------------------------------------+--------------+\n");
break;
case 1:
printf("+-------------------------------------+\n");
break;
default:
pmesg(LOG_ERROR, __FILE__, __LINE__, "List level unrecognized\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_BAD_LEVEL);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
printf(OPH_PRIMITIVES_LIST_HELP_MESSAGE);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_PRIMITIVES_LIST_TIP)) {
if (oph_json_add_text(handle->operator_json, OPH_JSON_OBJKEY_PRIMITIVES_LIST_TIP, "Useful Tip", OPH_PRIMITIVES_LIST_HELP_MESSAGE)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD TEXT error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
logging(LOG_INFO, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_INFO_END);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int task_execute(oph_operator_struct * handle)
{
if (!handle || !handle->operator_handle) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_NULL_OPERATOR_HANDLE);
return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE;
}
if (((OPH_SCRIPT_operator_handle *) handle->operator_handle)->list
&& oph_json_is_objkey_printable(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys_num,
OPH_JSON_OBJKEY_SCRIPT)) {
char config[OPH_COMMON_BUFFER_LEN];
snprintf(config, OPH_COMMON_BUFFER_LEN, OPH_FRAMEWORK_SCRIPT_CONF_FILE_PATH, OPH_ANALYTICS_LOCATION);
FILE *file = fopen(config, "r");
if (!file) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "%s: no such file\n", config);
logging(LOG_ERROR, __FILE__, __LINE__, 0, "%s: no such file\n", config);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
char **jsonkeys = NULL, **fieldtypes = NULL;
int num_fields = 1, iii, jjj = 0;
#if defined(OPH_DEBUG_LEVEL_1) || defined(OPH_DEBUG_LEVEL_2)
num_fields = 2;
#endif
jsonkeys = (char **) malloc(sizeof(char *) * num_fields);
if (!jsonkeys) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "keys");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
jsonkeys[jjj] = strdup("SCRIPT");
if (!jsonkeys[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "key");
for (iii = 0; iii < jjj; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#if defined(OPH_DEBUG_LEVEL_1) || defined(OPH_DEBUG_LEVEL_2)
jjj++;
jsonkeys[jjj] = strdup("COMMAND");
if (!jsonkeys[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "key");
for (iii = 0; iii < jjj; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#endif
jjj = 0;
fieldtypes = (char **) malloc(sizeof(char *) * num_fields);
if (!fieldtypes) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "fieldtypes");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
fieldtypes[jjj] = strdup(OPH_JSON_STRING);
if (!fieldtypes[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "fieldtype");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < jjj; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#if defined(OPH_DEBUG_LEVEL_1) || defined(OPH_DEBUG_LEVEL_2)
jjj++;
fieldtypes[jjj] = strdup(OPH_JSON_STRING);
if (!fieldtypes[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "fieldtype");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < jjj; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#endif
jjj++;
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_SCRIPT, "Available scripts", NULL, jsonkeys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < num_fields; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < num_fields; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
char script[OPH_COMMON_BUFFER_LEN], *pch, *save_pointer, *key, *value, **jsonvalues;
while (fgets(script, OPH_COMMON_BUFFER_LEN, file)) {
save_pointer = NULL;
key = NULL;
value = NULL;
for (pch = strtok_r(script, OPH_SCRIPT_NOP, &save_pointer); pch; pch = strtok_r(NULL, OPH_SCRIPT_NOP, &save_pointer)) {
if (!key)
key = pch;
else if (!value)
value = pch;
else
break;
}
if (!key || !strlen(key) || !value || !strlen(value))
continue;
if (value[strlen(value) - 1] == '\n')
value[strlen(value) - 1] = 0;
if (!strlen(value))
continue;
jjj = 0;
jsonvalues = (char **) calloc(num_fields, sizeof(char *));
if (!jsonvalues) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "values");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
jsonvalues[jjj] = strdup(key);
if (!jsonvalues[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "value");
for (iii = 0; iii < jjj; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#if defined(OPH_DEBUG_LEVEL_1) || defined(OPH_DEBUG_LEVEL_2)
jjj++;
jsonvalues[jjj] = strdup(value);
if (!jsonvalues[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_INPUT, "value");
for (iii = 0; iii < jjj; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
#endif
jjj++;
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_SCRIPT, jsonvalues)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
for (iii = 0; iii < num_fields; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (iii = 0; iii < num_fields; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
}
fclose(file);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
//Create dir if not exist
struct stat st;
if (stat(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path, &st)) {
if (oph_dir_r_mkdir(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "Unable to create dir %s\n", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path);
logging(LOG_WARNING, __FILE__, __LINE__, 0, OPH_LOG_GENERIC_DIR_CREATION_ERROR, ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path);
free(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path);
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path = NULL;
free(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url);
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url = NULL;
}
}
if (strcmp(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script, OPH_SCRIPT_NOP)) {
// Check for registered scripts
char config[OPH_COMMON_BUFFER_LEN];
snprintf(config, OPH_COMMON_BUFFER_LEN, OPH_FRAMEWORK_SCRIPT_CONF_FILE_PATH, OPH_ANALYTICS_LOCATION);
FILE *file = fopen(config, "r");
if (!file) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "%s: no such file\n", config);
logging(LOG_ERROR, __FILE__, __LINE__, 0, "%s: no such file\n", config);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
int found = 0;
char script[OPH_COMMON_BUFFER_LEN], *pch, *save_pointer, *key, *value;
while (fgets(script, OPH_COMMON_BUFFER_LEN, file)) {
save_pointer = NULL;
key = NULL;
value = NULL;
for (pch = strtok_r(script, OPH_SCRIPT_NOP, &save_pointer); pch; pch = strtok_r(NULL, OPH_SCRIPT_NOP, &save_pointer)) {
if (!key)
key = pch;
else if (!value)
value = pch;
else
break;
}
if (!key || !strlen(key) || !value || !strlen(value))
continue;
if (value[strlen(value) - 1] == '\n')
value[strlen(value) - 1] = 0;
if (!strlen(value))
continue;
if (!strcmp(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script, key)) {
pch = value;
while (pch && (*pch == ' '))
pch++;
if (!pch || !*pch)
continue;
else if (*pch != '/') {
snprintf(config, OPH_COMMON_BUFFER_LEN, OPH_FRAMEWORK_SCRIPT_FOLDER_PATH "/%s", OPH_ANALYTICS_LOCATION, value);
value = config;
}
free(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script = strdup(value);
found = 1;
break;
}
}
fclose(file);
if (!found) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "%s: no such script\n", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
logging(LOG_ERROR, __FILE__, __LINE__, 0, "%s: no such script\n", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
//If script is not a regular file then error
if (stat(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script, &st)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "%s: no such file\n", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
logging(LOG_ERROR, __FILE__, __LINE__, 0, "%s: no such file\n", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
char *ptr = realpath(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script, NULL);
if (!ptr) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to resolve path\n");
logging(LOG_ERROR, __FILE__, __LINE__, 0, "Unable to resolve path\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
if (!strncmp(ptr, "/bin/", 5) || !strncmp(ptr, "/sbin/", 6) || !strncmp(ptr, "/usr/bin/", 9) || !strncmp(ptr, "/usr/sbin/", 10)) {
free(ptr);
pmesg(LOG_ERROR, __FILE__, __LINE__, "Permission denied\n");
logging(LOG_ERROR, __FILE__, __LINE__, 0, "Permission denied\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
free(ptr);
}
char *base_src_path = NULL;
if (oph_pid_get_base_src_path(&base_src_path)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to read OphidiaDB configuration\n");
logging(LOG_ERROR, __FILE__, __LINE__, 0, "Unable to read OphidiaDB configuration\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
int error = 0, n = 0, i;
char command[OPH_COMMON_BUFFER_LEN];
memset(command, 0, OPH_COMMON_BUFFER_LEN);
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_DATA_PATH='%s' ", base_src_path ? base_src_path : "");
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_SESSION_PATH='%s' ",
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path ? ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path : "");
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_SESSION_URL='%s' ",
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url ? ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url : "");
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_SESSION_CODE='%s' ", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_code);
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_WORKFLOW_ID=%s ",
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id ? ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id : 0);
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "OPH_SCRIPT_MARKER_ID=%s ",
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->marker_id ? ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->marker_id : 0);
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "%s ", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script);
for (i = 0; i < ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args_num; i++) {
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "%s ", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args[i]);
}
if (strcmp(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->out_redir, "stdout")) {
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "1>>%s ", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->out_redir);
}
if (strcmp(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->err_redir, "stderr")) {
n += snprintf(command + n, OPH_COMMON_BUFFER_LEN - n, "2>>%s", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->err_redir);
}
// Dynamic creation of the folders
if (((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path) {
char dirname[OPH_COMMON_BUFFER_LEN];
snprintf(dirname, OPH_COMMON_BUFFER_LEN, "%s/%s", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path,
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id);
struct stat ss;
if (stat(dirname, &ss) && (errno == ENOENT)) {
int i;
for (i = 0; dirname[i]; ++i) {
if (dirname[i] == '/') {
dirname[i] = 0;
mkdir(dirname, 0755);
dirname[i] = '/';
}
}
mkdir(dirname, 0755);
}
}
char system_output[MAX_OUT_LEN];
memset(system_output, 0, MAX_OUT_LEN);
char line[OPH_COMMON_BUFFER_LEN];
snprintf(system_output, MAX_OUT_LEN, "Command: %s\n\n", command);
int s = 0, so = 1;
FILE *fp = popen(command, "r");
if (!fp)
error = -1;
else {
while (fgets(line, OPH_COMMON_BUFFER_LEN, fp))
if ((s = MAX_OUT_LEN - strlen(system_output)) > 1)
strncat(system_output, line, s);
error = pclose(fp);
}
// ADD COMMAND TO JSON AS TEXT
s = oph_json_is_objkey_printable(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys_num,
OPH_JSON_OBJKEY_SCRIPT);
#if defined(OPH_DEBUG_LEVEL_1) || defined(OPH_DEBUG_LEVEL_2)
if (s && oph_json_add_text(handle->operator_json, OPH_JSON_OBJKEY_SCRIPT, "System output", system_output)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD TEXT error\n");
}
so = 0;
#endif
if (((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path) {
if (((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id)
snprintf(system_output, MAX_OUT_LEN, "%s/%s", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url,
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id);
else
snprintf(system_output, MAX_OUT_LEN, "%s", ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url);
if (s && oph_json_add_text(handle->operator_json, OPH_JSON_OBJKEY_SCRIPT, "Output URL", system_output)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD TEXT error\n");
}
} else {
if (so && s && oph_json_add_text(handle->operator_json, OPH_JSON_OBJKEY_SCRIPT, "SUCCESS", NULL)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD TEXT error\n");
}
}
// ADD OUTPUT PID TO NOTIFICATION STRING
if (((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url) {
char tmp_string[OPH_COMMON_BUFFER_LEN];
snprintf(tmp_string, OPH_COMMON_BUFFER_LEN, "%s=%s;", OPH_IN_PARAM_LINK, s ? system_output : ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url);
if (handle->output_string) {
strncat(tmp_string, handle->output_string, OPH_COMMON_BUFFER_LEN - strlen(tmp_string));
free(handle->output_string);
}
handle->output_string = strdup(tmp_string);
}
if (error == -1) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "System command failed\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_COMMAND_FAILED);
return OPH_ANALYTICS_OPERATOR_COMMAND_ERROR;
} else if (WEXITSTATUS(error) == 127) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "System command cannot be executed\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_COMMAND_NOT_EXECUTED);
return OPH_ANALYTICS_OPERATOR_COMMAND_ERROR;
} else if (WEXITSTATUS(error) != 0) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Command failed with code %d\n", WEXITSTATUS(error));
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Command failed with code %d\n", WEXITSTATUS(error));
return OPH_ANALYTICS_OPERATOR_COMMAND_ERROR;
} else
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int recursive_search(const char *folder_abs_path, int folderid, const char *filters, ophidiadb * oDB, int *max_lengths, int max_lengths_size, char *query, char *path, int is_start,
oph_json * oper_json, int is_objkey_printable)
{
if (!oDB) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null input parameter\n");
return OPH_ODB_NULL_PARAM;
}
if (oph_odb_check_connection_to_ophidiadb(oDB)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to reconnect to OphidiaDB.\n");
return OPH_ODB_MYSQL_ERROR;
}
MYSQL_RES *res;
MYSQL_FIELD *fields;
MYSQL_ROW row;
int i, j, num_fields;
char *buffer;
char *buffer2;
if (is_start) {
buffer = malloc(MYSQL_BUFLEN);
if (!buffer) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory for query\n");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
buffer2 = malloc(MYSQL_BUFLEN);
if (!buffer2) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory for path\n");
free(buffer);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
} else {
buffer = query;
buffer2 = path;
}
snprintf(buffer, MYSQL_BUFLEN, MYSQL_QUERY_OPH_SEARCH_READ_INSTANCES, folderid, filters);
if (mysql_query(oDB->conn, buffer)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "MySQL query error: %s\n", mysql_error(oDB->conn));
free(buffer);
free(buffer2);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
res = mysql_store_result(oDB->conn);
fields = mysql_fetch_fields(res);
num_fields = mysql_num_fields(res) - 1;
if (is_start) {
//print header
printf("+");
for (i = 0; i < max_lengths_size; i++) {
printf("-");
for (j = 0; j < max_lengths[i]; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
printf("|");
for (i = 0; i < max_lengths_size; i++) {
printf(" ");
printf("%-*s", max_lengths[i], fields[i].name);
printf(" |");
}
printf("\n");
printf("+");
for (i = 0; i < max_lengths_size; i++) {
printf("-");
for (j = 0; j < max_lengths[i]; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
if (is_objkey_printable) {
char **jsonkeys = NULL;
char **fieldtypes = NULL;
int iii, jjj;
jsonkeys = (char **) malloc(sizeof(char *) * num_fields);
if (!jsonkeys) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "keys");
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj = 0; jjj < num_fields; ++jjj) {
jsonkeys[jjj] = strdup(fields[jjj + 1].name ? fields[jjj + 1].name : "");
if (!jsonkeys[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "key");
for (iii = 0; iii < jjj; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
fieldtypes = (char **) malloc(sizeof(char *) * num_fields);
if (!fieldtypes) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "fieldtypes");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj = 0; jjj < num_fields; ++jjj) {
fieldtypes[jjj] = strdup(OPH_JSON_STRING);
if (!fieldtypes[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "fieldtype");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < jjj; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_add_grid(oper_json, OPH_JSON_OBJKEY_SEARCH, "Searching results", NULL, jsonkeys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID error\n");
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < num_fields; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++)
if (jsonkeys[iii])
free(jsonkeys[iii]);
if (jsonkeys)
free(jsonkeys);
for (iii = 0; iii < num_fields; iii++)
if (fieldtypes[iii])
free(fieldtypes[iii]);
if (fieldtypes)
free(fieldtypes);
}
}
//print each ROW
while ((row = mysql_fetch_row(res))) {
printf("|");
for (i = 0; i < max_lengths_size; i++) {
printf(" ");
if (!strcasecmp(fields[i].name, "Container")) {
if (folder_abs_path[strlen(folder_abs_path) - 1] == '/') {
snprintf(buffer2, MYSQL_BUFLEN, "%s%s", folder_abs_path, row[i]);
} else {
snprintf(buffer2, MYSQL_BUFLEN, "%s/%s", folder_abs_path, row[i]);
}
printf("%-*s", max_lengths[i], buffer2);
} else {
printf("%-*s", max_lengths[i], row[i]);
}
printf(" |");
}
printf("\n");
if (is_objkey_printable) {
char **jsonvalues = NULL;
int iii, jjj;
jsonvalues = (char **) calloc(num_fields, sizeof(char *));
if (!jsonvalues) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "values");
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj = 0; jjj < num_fields; ++jjj) {
if (jjj)
jsonvalues[jjj] = strdup(row[1 + jjj] ? row[1 + jjj] : "");
else {
char *tmp_uri = NULL, *pid = NULL;
if (oph_pid_get_uri(&tmp_uri)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "PID");
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (oph_pid_create_pid(tmp_uri, (int) strtol(row[0], NULL, 10), (int) strtol(row[1], NULL, 10), &pid)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to create PID string\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "PID");
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (tmp_uri)
free(tmp_uri);
jsonvalues[jjj] = strdup(pid ? pid : "");
}
if (!jsonvalues[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_INPUT, "value");
for (iii = 0; iii < jjj; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_add_grid_row(oper_json, OPH_JSON_OBJKEY_SEARCH, jsonvalues)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "ADD GRID ROW error\n");
for (iii = 0; iii < num_fields; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++)
if (jsonvalues[iii])
free(jsonvalues[iii]);
if (jsonvalues)
free(jsonvalues);
}
}
mysql_free_result(res);
//recursive step
snprintf(buffer, MYSQL_BUFLEN, MYSQL_QUERY_OPH_SEARCH_READ_SUBFOLDERS, folderid);
if (mysql_query(oDB->conn, buffer)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "MySQL query error: %s\n", mysql_error(oDB->conn));
free(buffer);
free(buffer2);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
res = mysql_store_result(oDB->conn);
while ((row = mysql_fetch_row(res))) {
if (folder_abs_path[strlen(folder_abs_path) - 1] == '/') {
snprintf(buffer2, MYSQL_BUFLEN, "%s%s/", folder_abs_path, row[1]);
} else {
snprintf(buffer2, MYSQL_BUFLEN, "%s/%s/", folder_abs_path, row[1]);
}
char *subfolder_path = strdup(buffer2);
if (!subfolder_path) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory for subfolder path\n");
free(buffer);
free(buffer2);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (recursive_search(subfolder_path, (int) strtol(row[0], NULL, 10), filters, oDB, max_lengths, max_lengths_size, buffer, buffer2, 0, oper_json, is_objkey_printable)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Recursive step error\n");
free(buffer);
free(buffer2);
free(subfolder_path);
mysql_free_result(res);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
free(subfolder_path);
}
mysql_free_result(res);
if (is_start) {
//print footer
printf("+");
for (i = 0; i < max_lengths_size; i++) {
printf("-");
for (j = 0; j < max_lengths[i]; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
if (buffer) {
free(buffer);
buffer = NULL;
}
if (buffer2) {
free(buffer2);
buffer2 = NULL;
}
}
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int task_execute(oph_operator_struct *handle)
{
if (!handle || !handle->operator_handle){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_NULL_OPERATOR_HANDLE);
return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE;
}
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
logging(LOG_INFO,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_INFO_START);
char *name_filter = ((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->name_filter;
int limit = ((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->limit;
char list[1000];
snprintf(list, sizeof(list), OPH_ANALYTICS_DYNAMIC_LIBRARY_FILE_PATH, OPH_ANALYTICS_LOCATION);
FILE *file = fopen(list, "r");
if(file == NULL)
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "Drivers list file not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_FILE_NOT_FOUND);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
char buffer[256],operator[30];
char *position1,*position2;
char **oplist;
int i,j,oplist_size=0;
// get oplist size
if (limit==0) {
//no limit
while (fscanf(file, "%s", buffer) != EOF)
{
position1 = strchr(buffer, '[');
if (position1 != NULL) {
position2 = strchr(position1+1,']');
if (position2 == NULL) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Matching closing bracket not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_BRACKET_NOT_FOUND);
fclose(file);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
strncpy(operator,position1+1,strlen(position1)-strlen(position2)-1);
operator[strlen(position1)-strlen(position2)-1] = 0;
if (name_filter==NULL) {
oplist_size++;
} else {
if (strcasestr(operator,name_filter)) {
oplist_size++;
}
}
}
}
} else {
int count=0;
while (fscanf(file, "%s", buffer) != EOF && count < limit)
{
position1 = strchr(buffer, '[');
if (position1 != NULL) {
position2 = strchr(position1+1,']');
if (position2 == NULL) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Matching closing bracket not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_BRACKET_NOT_FOUND);
fclose(file);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
strncpy(operator,position1+1,strlen(position1)-strlen(position2)-1);
operator[strlen(position1)-strlen(position2)-1] = 0;
if (name_filter==NULL) {
oplist_size++;
count++;
} else {
if (strcasestr(operator,name_filter)) {
oplist_size++;
count++;
}
}
}
}
}
fclose(file);
// alloc oplist
oplist = (char **)malloc(sizeof(char *)*oplist_size);
if (!oplist) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"Error allocating memory\n");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (i = 0; i < oplist_size; i++) {
oplist[i] = (char *)malloc(OPH_COMMON_BUFFER_LEN);
if (!oplist[i]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory for path\n");
for (j = 0; j < i; j++) {
free(oplist[j]);
}
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
// fill oplist
int p=0;
file = fopen(list, "r");
if(file == NULL)
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "Drivers list file not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_FILE_NOT_FOUND);
for (i = 0; i < oplist_size; i++) {
free(oplist[i]);
}
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (limit==0) {
//no limit
while (fscanf(file, "%s", buffer) != EOF)
{
position1 = strchr(buffer, '[');
if (position1 != NULL) {
position2 = strchr(position1+1,']');
if (position2 == NULL) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Matching closing bracket not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_BRACKET_NOT_FOUND);
fclose(file);
for (i = 0; i < oplist_size; i++) {
free(oplist[i]);
}
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
strncpy(operator,position1+1,strlen(position1)-strlen(position2)-1);
operator[strlen(position1)-strlen(position2)-1] = 0;
if (name_filter==NULL) {
strncpy(oplist[p],operator,strlen(operator));
oplist[p][strlen(operator)] = 0;
p++;
} else {
if (strcasestr(operator,name_filter)) {
strncpy(oplist[p],operator,strlen(operator));
oplist[p][strlen(operator)] = 0;
p++;
}
}
}
}
} else {
int count=0;
while (fscanf(file, "%s", buffer) != EOF && count < limit)
{
position1 = strchr(buffer, '[');
if (position1 != NULL) {
position2 = strchr(position1+1,']');
if (position2 == NULL) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Matching closing bracket not found\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_BRACKET_NOT_FOUND);
fclose(file);
for (i = 0; i < oplist_size; i++) {
free(oplist[i]);
}
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
strncpy(operator,position1+1,strlen(position1)-strlen(position2)-1);
operator[strlen(position1)-strlen(position2)-1] = 0;
if (name_filter==NULL) {
strncpy(oplist[p],operator,strlen(operator));
oplist[p][strlen(operator)] = 0;
p++;
count++;
} else {
if (strcasestr(operator,name_filter)) {
strncpy(oplist[p],operator,strlen(operator));
oplist[p][strlen(operator)] = 0;
p++;
count++;
}
}
}
}
}
fclose(file);
// sort oplist
qsort(oplist,oplist_size,sizeof(char*),strcmp2);
printf("+-----------------------------+\n");
printf("| OPERATORS |\n");
printf("+-----------------------------+\n");
for (i = 0; i < oplist_size; i++) {
printf("| %-27s |\n",oplist[i]);
}
printf("+-----------------------------+\n");
int is_objkey_printable = oph_json_is_objkey_printable(((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys,((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys_num,OPH_JSON_OBJKEY_OPERATORS_LIST_LIST);
if (is_objkey_printable)
{
// Header
char **jsonkeys = NULL;
char **fieldtypes = NULL;
int num_fields = 1, iii,jjj=0;
jsonkeys = (char **)malloc(sizeof(char *)*num_fields);
if (!jsonkeys) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "keys" );
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
jsonkeys[jjj] = strdup("OPERATORS");
if (!jsonkeys[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "key" );
for (iii=0;iii<jjj;iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
jjj = 0;
fieldtypes = (char **)malloc(sizeof(char *)*num_fields);
if (!fieldtypes) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "fieldtypes" );
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
fieldtypes[jjj] = strdup(OPH_JSON_STRING);
if (!fieldtypes[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "fieldtype" );
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < jjj; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
if (oph_json_add_grid(handle->operator_json,OPH_JSON_OBJKEY_OPERATORS_LIST_LIST,"Operators List",NULL,jsonkeys,num_fields,fieldtypes,num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD GRID error\n");
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < num_fields; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < num_fields; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
// Data
char **jsonvalues = NULL;
jsonvalues = (char **)calloc(num_fields,sizeof(char *));
if (!jsonvalues) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "values" );
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (i = 0; i < oplist_size; i++)
{
for (jjj = 0; jjj < num_fields; jjj++)
{
jsonvalues[jjj] = strdup(oplist[i]);
if (!jsonvalues[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MEMORY_ERROR_INPUT, "value" );
for (iii = 0; iii < jjj; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
if (jsonvalues) free(jsonvalues);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_add_grid_row(handle->operator_json,OPH_JSON_OBJKEY_OPERATORS_LIST_LIST,jsonvalues)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD GRID ROW error\n");
for (iii = 0; iii < num_fields; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
if (jsonvalues) free(jsonvalues);
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
}
if (jsonvalues) free(jsonvalues);
}
for (i = 0; i < oplist_size; i++) free(oplist[i]);
free(oplist);
printf(OPH_OPERATORS_LIST_HELP_MESSAGE);
if (oph_json_is_objkey_printable(((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys,((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys_num,OPH_JSON_OBJKEY_OPERATORS_LIST_TIP))
{
if (oph_json_add_text(handle->operator_json,OPH_JSON_OBJKEY_OPERATORS_LIST_TIP,"Help Message",OPH_OPERATORS_LIST_HELP_MESSAGE))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD TEXT error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
logging(LOG_INFO,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_INFO_END);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int task_execute(oph_operator_struct * handle)
{
if (!handle || !handle->operator_handle) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n");
logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_CUBEIO_NULL_OPERATOR_HANDLE);
return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE;
}
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
ophidiadb *oDB = &((OPH_CUBEIO_operator_handle *) handle->operator_handle)->oDB;
int direction = ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->direction;
char *datacube_name = ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->datacube_name;
char **objkeys = ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys;
int objkeys_num = ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys_num;
char operation[OPH_ODB_CUBE_OPERATOR_SIZE];
memset(operation, 0, OPH_ODB_CUBE_OPERATOR_SIZE);
char parentcube_name[OPH_COMMON_BUFFER_LEN];
memset(parentcube_name, 0, OPH_COMMON_BUFFER_LEN);
int *type = (int *) malloc(sizeof(int));
type[0] = 0;
oph_odb_datacube cube;
oph_odb_cube_init_datacube(&cube);
//retrieve input datacube
if (oph_odb_cube_retrieve_datacube(oDB, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_datacube, &cube)) {
oph_odb_cube_free_datacube(&cube);
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while retrieving input datacube\n");
logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_CUBEIO_DATACUBE_READ_ERROR);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
char source_buffer[OPH_PID_SIZE];
char source_buffer_json[OPH_PID_SIZE];
oph_odb_source src;
if (cube.id_source) {
//retrieve input datacube
if (oph_odb_cube_retrieve_source(oDB, cube.id_source, &src)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while retrieving source name\n");
logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_CUBEIO_SOURCE_READ_ERROR);
oph_odb_cube_free_datacube(&cube);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
} else {
snprintf(source_buffer, OPH_PID_SIZE, "- SOURCE: %s", src.uri);
snprintf(source_buffer_json, OPH_PID_SIZE, "%s", src.uri);
}
} else {
source_buffer[0] = 0;
source_buffer_json[0] = 0;
}
oph_odb_cube_free_datacube(&cube);
char *tmp_uri = NULL;
if (oph_pid_get_uri(&tmp_uri)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve web server URI.\n");
logging(LOG_WARNING, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_PID_URI_ERROR);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO)) {
int num_fields = 4;
char *keys[4] = { "INPUT CUBE", "OPERATION", "OUTPUT CUBE", "SOURCE" };
char *fieldtypes[4] = { "string", "string", "string", "string" };
if (oph_json_add_grid(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO, "Cube Provenance", NULL, keys, num_fields, fieldtypes, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output grid");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
int num_fields = 2;
char *keys[2] = { "PID", "SOURCE" };
if (oph_json_add_graph(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, 1, "Cube Provenance Graph", NULL, keys, num_fields)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (direction != OPH_CUBEIO_BRANCH_OUT) {
//Retrieve upper hierarchy
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
unsigned int nn, nnn;
int found = 0;
for (nn = 0; nn < handle->operator_json->response_num; nn++) {
if (!strcmp(handle->operator_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (handle->operator_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (!strcmp(datacube_name, ((oph_json_obj_graph *) (handle->operator_json->response[nn].objcontent))[0].nodevalues[nnn][0])) {
found = 1;
break;
}
}
break;
}
}
char *my_row[2] = { datacube_name, source_buffer_json };
if (!found) {
if (oph_json_add_graph_node(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH NODE error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph node");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
}
if (_oph_cubeio_print_parents
(tmp_uri, oDB, 0, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_datacube, &type, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container,
&operation, handle->operator_json, objkeys, objkeys_num, datacube_name, &parentcube_name)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error launching parents search function\n");
logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_CUBEIO_HIERARCHY_FUNCT_ERROR, "parent",
datacube_name);
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
printf("--> %s (%s) %s\n", datacube_name, operation, source_buffer);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO)) {
char *my_row[4] = { parentcube_name, operation, datacube_name, source_buffer_json };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output grid row");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
}
if (direction != OPH_CUBEIO_BRANCH_IN) {
//Retrive lower hierarchy
if (direction != 0) {
printf("--> %s (%s) %s\n", datacube_name, "ROOT", source_buffer);
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO)) {
char *my_row[4] = { "", "ROOT", datacube_name, source_buffer_json };
if (oph_json_add_grid_row(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output grid row");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
unsigned int nn, nnn;
int found = 0;
for (nn = 0; nn < handle->operator_json->response_num; nn++) {
if (!strcmp(handle->operator_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (handle->operator_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (!strcmp(datacube_name, ((oph_json_obj_graph *) (handle->operator_json->response[nn].objcontent))[0].nodevalues[nnn][0])) {
found = 1;
break;
}
}
break;
}
}
char *my_row[2] = { datacube_name, source_buffer_json };
if (!found) {
if (oph_json_add_graph_node(handle->operator_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH NODE error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph node");
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
}
}
if (_oph_cubeio_print_children
(tmp_uri, oDB, 0, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_datacube, &type, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container,
handle->operator_json, objkeys, objkeys_num)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error launching children search function\n");
logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_CUBEIO_HIERARCHY_FUNCT_ERROR, "children",
datacube_name);
free(type);
if (tmp_uri)
free(tmp_uri);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (tmp_uri)
free(tmp_uri);
free(type);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int _oph_cubeio_print_parents(char *uri, ophidiadb * oDB, unsigned int level, int id_datacube_leaf, int **parent_type, int id_container_in, char (*operation)[OPH_ODB_CUBE_OPERATOR_SIZE],
oph_json * oper_json, char **objkeys, int objkeys_num, char childcube[OPH_COMMON_BUFFER_LEN], char (*parentcube)[OPH_COMMON_BUFFER_LEN])
{
if (id_datacube_leaf < 1 || id_container_in < 1 || (*parent_type) == 0 || !oDB || !operation || !childcube || !parentcube) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null input parameter\n");
logging(LOG_ERROR, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NULL_FUNCTION_PARAMS_PARENT, id_datacube_leaf);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
level++;
MYSQL_RES *io_datacubes = NULL;
int num_rows = 0;
MYSQL_ROW row;
unsigned int i, j, length;
int *new_type = NULL;
int kk = 0;
if (oph_odb_cube_find_datacube_hierarchy(oDB, 1, id_datacube_leaf, &io_datacubes)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "Unable to retreive information of input output datacubes\n");
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_IO_DATACUBE_READ_ERROR, id_datacube_leaf);
mysql_free_result(io_datacubes);
//Prepare operation for root element
length = strlen("ROOT") + 1;
strncpy(*operation, "ROOT", length);
(*operation)[length] = '\0';
snprintf(*parentcube, OPH_COMMON_BUFFER_LEN, "%s", "");
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
char parent_operation[OPH_ODB_CUBE_OPERATOR_SIZE];
memset(parent_operation, 0, OPH_ODB_CUBE_OPERATOR_SIZE);
char parent_parentcube[OPH_COMMON_BUFFER_LEN];
memset(parent_parentcube, 0, OPH_COMMON_BUFFER_LEN);
char source_buffer[OPH_PID_SIZE];
char source_buffer_json[OPH_PID_SIZE];
//Empty set
if (!(num_rows = mysql_num_rows(io_datacubes))) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "No rows find by query\n");
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NO_ROWS_FOUND);
//Prepare operation for root element
length = strlen("ROOT") + 1;
strncpy(*operation, "ROOT", length);
(*operation)[length] = '\0';
snprintf(*parentcube, OPH_COMMON_BUFFER_LEN, "%s", "");
} else {
if (mysql_field_count(oDB->conn) != 4) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "No rows find by query\n");
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NO_ROWS_FOUND);
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
i = 0;
char *pid;
int ii = 0;
while ((row = mysql_fetch_row(io_datacubes))) {
new_type = (int *) realloc(*parent_type, (level + 1) * sizeof(int));
if (!new_type) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "parent_type array");
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
} else {
*parent_type = new_type;
}
(*parent_type)[level] = i;
if (uri && row[0] && row[2]) {
if (oph_pid_create_pid(uri, (int) strtol(row[0], NULL, 10), (int) strtol(row[2], NULL, 10), &pid)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to create PID string\n");
if (pid)
free(pid);
pid = NULL;
}
}
//Prepare operation for children elements
length = (strlen(row[1]) >= (OPH_ODB_CUBE_OPERATOR_SIZE - 1) ? OPH_ODB_CUBE_OPERATOR_SIZE : strlen(row[1]) + 1);
strncpy(*operation, (row[1] ? row[1] : "-"), length);
(*operation)[length] = '\0';
if (row[3]) {
snprintf(source_buffer, OPH_PID_SIZE, "- SOURCE: %s", row[3]);
snprintf(source_buffer_json, OPH_PID_SIZE, "%s", row[3]);
} else {
source_buffer[0] = 0;
source_buffer_json[0] = 0;
}
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
unsigned int nn, nnn;
int found = 0;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (!strcmp((pid ? pid : ""), ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0])) {
found = 1;
break;
}
}
break;
}
}
char *my_row[2] = { (pid ? pid : ""), source_buffer_json };
if (!found) {
if (oph_json_add_graph_node(oper_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH NODE error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph node");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
int node1 = -1, node2 = -1;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (node1 != -1 && node2 != -1)
break;
if (!strcmp((pid ? pid : ""), ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0]))
node1 = nnn;
else if (!strcmp(childcube, ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0]))
node2 = nnn;
}
break;
}
}
int node_link = 0;
found = 0;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) oper_json->response[nn].objcontent)[0].nodelinks[node1].links_num; nnn++) {
node_link = (int) strtol(((oph_json_obj_graph *) oper_json->response[nn].objcontent)[0].nodelinks[node1].links[nnn].node, NULL, 10);
if (node_link == node2) {
found = 1;
break;
}
}
if (found == 1)
break;
}
}
if (!found) {
if (oph_json_add_graph_link(oper_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, node1, node2, (const char *) operation)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH LINK error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph link");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
}
if (_oph_cubeio_print_parents
(uri, oDB, level, (int) strtol(row[2], NULL, 10), parent_type, id_container_in, &parent_operation, oper_json, objkeys, objkeys_num, pid, &parent_parentcube))
break;
ii++;
if (ii == num_rows)
kk += snprintf((*parentcube) + kk, OPH_COMMON_BUFFER_LEN - kk, "%s", (pid ? pid : ""));
else
kk += snprintf((*parentcube) + kk, OPH_COMMON_BUFFER_LEN - kk, "%s - ", (pid ? pid : ""));
//Shift output string proportionally to its level
for (j = 1; j < level; j++) {
if ((*parent_type)[j]) {
printf(" │ ");
} else {
printf(" ");
}
}
//If first element of tree
if (!i) {
printf(" ┌─ %s (%s) %s\n", (pid ? pid : "-"), parent_operation, source_buffer);
} else {
printf(" ├─ %s (%s) %s\n", (pid ? pid : "-"), parent_operation, source_buffer);
}
i++;
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO)) {
char *my_row[4] = { parent_parentcube, parent_operation, (pid ? pid : ""), source_buffer_json };
if (oph_json_add_grid_row(oper_json, OPH_JSON_OBJKEY_CUBEIO, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output grid row");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (pid)
free(pid);
pid = NULL;
}
}
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int _oph_cubeio_print_children(char *uri, ophidiadb * oDB, unsigned int level, int id_datacube_root, int **child_type, int id_container_in, oph_json * oper_json, char **objkeys, int objkeys_num)
{
if (id_datacube_root < 1 || id_container_in < 1 || (*child_type) == NULL || !oDB) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null input parameter\n");
logging(LOG_ERROR, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NULL_FUNCTION_PARAMS_CHILD, id_datacube_root);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
level++;
MYSQL_RES *io_datacubes = NULL;
int num_rows = 0;
MYSQL_ROW row;
unsigned int i, j;
int *new_type = NULL;
char source_buffer[OPH_PID_SIZE];
char source_buffer_json[OPH_PID_SIZE];
if (oph_odb_cube_find_datacube_hierarchy(oDB, 0, id_datacube_root, &io_datacubes)) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "Unable to retreive information of input output datacubes\n");
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_IO_DATACUBE_READ_ERROR, id_datacube_root);
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
//Empty set
if (!(num_rows = mysql_num_rows(io_datacubes))) {
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NO_ROWS_FOUND);
} else {
if (mysql_field_count(oDB->conn) != 4) {
pmesg(LOG_WARNING, __FILE__, __LINE__, "No enough fields found by query\n");
logging(LOG_WARNING, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_NO_ROWS_FOUND);
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
i = num_rows - 1;
char *pid = NULL;
char *pid2 = NULL; //root name
if (uri) {
if (oph_pid_create_pid(uri, id_container_in, id_datacube_root, &pid2)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to create PID string\n");
if (pid2)
free(pid2);
pid2 = NULL;
}
}
while ((row = mysql_fetch_row(io_datacubes))) {
new_type = (int *) realloc(*child_type, (level + 1) * sizeof(int));
if (!new_type) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, id_container_in, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "child_type array");
mysql_free_result(io_datacubes);
if (pid2)
free(pid2);
pid2 = NULL;
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
} else {
*child_type = new_type;
}
(*child_type)[level] = i;
//Shift output string proportionally to its level
for (j = 1; j < level; j++) {
if ((*child_type)[j]) {
printf(" │ ");
} else {
printf(" ");
}
}
if (uri && row[0] && row[2]) {
if (oph_pid_create_pid(uri, (int) strtol(row[0], NULL, 10), (int) strtol(row[2], NULL, 10), &pid)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to create PID string\n");
if (pid)
free(pid);
pid = NULL;
}
}
if (row[3]) {
snprintf(source_buffer, OPH_PID_SIZE, "- SOURCE: %s", row[3]);
snprintf(source_buffer_json, OPH_PID_SIZE, "%s", row[3]);
} else {
source_buffer[0] = 0;
source_buffer_json[0] = 0;
}
//If last element of tree
if (!i) {
printf(" └─ %s (%s) %s\n", (pid ? pid : "-"), (row[1] ? row[1] : "-"), source_buffer);
} else {
printf(" ├─ %s (%s) %s\n", (pid ? pid : "-"), (row[1] ? row[1] : "-"), source_buffer);
}
i--;
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO)) {
char *my_row[4] = { (pid2 ? pid2 : ""), (row[1] ? row[1] : ""), (pid ? pid : ""), source_buffer_json };
if (oph_json_add_grid_row(oper_json, OPH_JSON_OBJKEY_CUBEIO, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output grid row");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
if (pid2)
free(pid2);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_is_objkey_printable(objkeys, objkeys_num, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
unsigned int nn, nnn;
int found = 0;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (!strcmp((pid ? pid : ""), ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0])) {
found = 1;
break;
}
}
break;
}
}
char *my_row[2] = { (pid ? pid : ""), source_buffer_json };
if (!found) {
if (oph_json_add_graph_node(oper_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, my_row)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH NODE error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph node");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
if (pid2)
free(pid2);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
int node1 = -1, node2 = -1;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues_num1; nnn++) {
if (node1 != -1 && node2 != -1)
break;
if (!strcmp((pid2 ? pid2 : ""), ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0]))
node1 = nnn;
else if (!strcmp((pid ? pid : ""), ((oph_json_obj_graph *) (oper_json->response[nn].objcontent))[0].nodevalues[nnn][0]))
node2 = nnn;
}
break;
}
}
int node_link = 0;
found = 0;
for (nn = 0; nn < oper_json->response_num; nn++) {
if (!strcmp(oper_json->response[nn].objkey, OPH_JSON_OBJKEY_CUBEIO_GRAPH)) {
for (nnn = 0; nnn < ((oph_json_obj_graph *) oper_json->response[nn].objcontent)[0].nodelinks[node1].links_num; nnn++) {
node_link = (int) strtol(((oph_json_obj_graph *) oper_json->response[nn].objcontent)[0].nodelinks[node1].links[nnn].node, NULL, 10);
if (node_link == node2) {
found = 1;
break;
}
}
if (found == 1)
break;
}
}
if (!found) {
if (oph_json_add_graph_link(oper_json, OPH_JSON_OBJKEY_CUBEIO_GRAPH, node1, node2, (const char *) (row[1] ? row[1] : ""))) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRAPH LINK error\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR, "output graph link");
mysql_free_result(io_datacubes);
if (pid)
free(pid);
if (pid2)
free(pid2);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
}
if (_oph_cubeio_print_children(uri, oDB, level, (int) strtol(row[2], NULL, 10), child_type, id_container_in, oper_json, objkeys, objkeys_num))
break;
if (pid)
free(pid);
pid = NULL;
}
if (pid2)
free(pid2);
pid2 = NULL;
}
mysql_free_result(io_datacubes);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
int task_execute(oph_operator_struct *handle)
{
if (!handle || !handle->operator_handle){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_METADATA_NULL_OPERATOR_HANDLE);
return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE;
}
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
MYSQL_RES *read_result = NULL;
MYSQL_FIELD *fields;
MYSQL_ROW row;
int num_fields;
int num_rows;
int i,j,len;
//execute requested crud operation
if(oph_metadata_crud(((OPH_METADATA_operator_handle*)handle->operator_handle),&read_result)){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to manage metadata\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_METADATA_CRUD_ERROR);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
if (((OPH_METADATA_operator_handle*)handle->operator_handle)->mode==OPH_METADATA_MODE_READ_VALUE)
{
num_rows = mysql_num_rows(read_result);
char message[OPH_COMMON_BUFFER_LEN];
snprintf(message,OPH_COMMON_BUFFER_LEN,"Found %d items",num_rows);
printf("%s\n",message);
if (oph_json_is_objkey_printable(((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys,((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num,OPH_JSON_OBJKEY_METADATA_SUMMARY))
{
if (oph_json_add_text(handle->operator_json,OPH_JSON_OBJKEY_METADATA_SUMMARY,"Summary",message))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD TEXT error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
//Empty set
if(!num_rows){
pmesg(LOG_WARNING, __FILE__, __LINE__, "No rows found by query\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_METADATA_NO_ROWS_FOUND);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
fields = mysql_fetch_fields(read_result);
num_fields = mysql_num_fields(read_result);
printf("+");
for (i = 0; i < num_fields; i++) {
printf("-");
len = (fields[i].max_length > fields[i].name_length)?fields[i].max_length:fields[i].name_length;
for (j = 0; j < len; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
printf("|");
for (i = 0; i < num_fields; i++) {
printf(" ");
len = (fields[i].max_length > fields[i].name_length)?fields[i].max_length:fields[i].name_length;
printf("%-*s",len,fields[i].name);
printf(" |");
}
printf("\n");
int objkey_printable = oph_json_is_objkey_printable(((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys,((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num,OPH_JSON_OBJKEY_METADATA_LIST), iii, jjj;
if (objkey_printable)
{
char **jsonkeys = NULL;
char **fieldtypes = NULL;
jsonkeys = (char **)malloc(sizeof(char *)*num_fields);
if (!jsonkeys) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "keys" );
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj=0;jjj<num_fields;++jjj)
{
jsonkeys[jjj] = strdup(fields[jjj].name ? fields[jjj].name : "");
if (!jsonkeys[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "key" );
for (iii=0;iii<jjj;iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
fieldtypes = (char **)malloc(sizeof(char *)*num_fields);
if (!fieldtypes) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "fieldtypes" );
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj=0;jjj<num_fields;++jjj)
{
fieldtypes[jjj] = strdup(OPH_JSON_STRING);
if (!fieldtypes[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "fieldtype" );
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < jjj; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_add_grid(handle->operator_json,OPH_JSON_OBJKEY_METADATA_LIST,"Searching results",NULL,jsonkeys,num_fields,fieldtypes,num_fields))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD GRID error\n");
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < num_fields; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++) if (jsonkeys[iii]) free(jsonkeys[iii]);
if (jsonkeys) free(jsonkeys);
for (iii = 0; iii < num_fields; iii++) if (fieldtypes[iii]) free(fieldtypes[iii]);
if (fieldtypes) free(fieldtypes);
}
printf("+");
for (i = 0; i < num_fields; i++) {
printf("-");
len = (fields[i].max_length > fields[i].name_length)?fields[i].max_length:fields[i].name_length;
for (j = 0; j < len; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
//For each ROW
while((row = mysql_fetch_row(read_result))){
printf("|");
for (i = 0; i < num_fields; i++) {
printf(" ");
len = (fields[i].max_length > fields[i].name_length)?fields[i].max_length:fields[i].name_length;
printf("%-*s",len,row[i]?row[i]:"");
printf(" |");
}
printf("\n");
if (objkey_printable)
{
char **jsonvalues = NULL;
jsonvalues = (char **)calloc(num_fields,sizeof(char *));
if (!jsonvalues) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "values" );
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
for (jjj=0;jjj<num_fields;++jjj)
{
jsonvalues[jjj] = strdup(row[jjj] ? row[jjj] : "");
if (!jsonvalues[jjj]) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MEMORY_ERROR_INPUT, "value" );
for (iii = 0; iii < jjj; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
if (jsonvalues) free(jsonvalues);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (oph_json_add_grid_row(handle->operator_json,OPH_JSON_OBJKEY_METADATA_LIST,jsonvalues))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD GRID ROW error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD GRID ROW error\n");
for (iii = 0; iii < num_fields; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
if (jsonvalues) free(jsonvalues);
mysql_free_result(read_result);
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
for (iii = 0; iii < num_fields; iii++) if (jsonvalues[iii]) free(jsonvalues[iii]);
if (jsonvalues) free(jsonvalues);
}
}
printf("+");
for (i = 0; i < num_fields; i++) {
printf("-");
len = (fields[i].max_length > fields[i].name_length)?fields[i].max_length:fields[i].name_length;
for (j = 0; j < len; j++) {
printf("-");
}
printf("-+");
}
printf("\n");
mysql_free_result(read_result);
} else {
char message[OPH_COMMON_BUFFER_LEN];
snprintf(message,OPH_COMMON_BUFFER_LEN,"Operation successfully completed!");
printf("%s\n",message);
if (oph_json_is_objkey_printable(((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys,((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num,OPH_JSON_OBJKEY_METADATA_SUMMARY))
{
if (oph_json_add_text(handle->operator_json,OPH_JSON_OBJKEY_METADATA_SUMMARY,"Summary",message))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, "ADD TEXT error\n");
logging(LOG_WARNING,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,"ADD TEXT error\n");
return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR;
}
}
}
return OPH_ANALYTICS_OPERATOR_SUCCESS;
}
