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_SEARCH_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; int folderid; char *abs_path = NULL; char *filters = NULL; int *max_lengths = NULL; int max_lengths_size; int permission = 0; ophidiadb *oDB = &((OPH_SEARCH_operator_handle *) handle->operator_handle)->oDB; if (!strcasecmp(((OPH_SEARCH_operator_handle *) handle->operator_handle)->path, OPH_FRAMEWORK_FS_DEFAULT_PATH)) { if (oph_odb_fs_path_parsing(".", ((OPH_SEARCH_operator_handle *) handle->operator_handle)->cwd, &folderid, &abs_path, oDB)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse path\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_PATH_PARSING_ERROR); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } } else { if (oph_odb_fs_path_parsing(((OPH_SEARCH_operator_handle *) handle->operator_handle)->path, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->cwd, &folderid, &abs_path, oDB)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse path '%s/%s'\n", ((OPH_SEARCH_operator_handle *) handle->operator_handle)->cwd, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->path); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_PATH_PARSING_ERROR); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } } if ((oph_odb_fs_check_folder_session(folderid, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->sessionid, oDB, &permission)) || !permission) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Path %s not allowed\n", abs_path); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_PATH_NOT_ALLOWED_ERROR, abs_path); if (abs_path) { free(abs_path); abs_path = NULL; } return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } // Change folder_to_be_printed in user format if (abs_path) { char old_abs_path[1 + strlen(abs_path)]; strcpy(old_abs_path, abs_path); free(abs_path); abs_path = NULL; if (oph_pid_drop_session_prefix(old_abs_path, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->sessionid, &abs_path)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Folder conversion error\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Folder conversion error\n"); if (abs_path) { free(abs_path); abs_path = NULL; } return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } } if (get_filters_string (((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter_num, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter_num, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter_num, &filters)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse filters\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_FILTERS_PARSING_ERROR); if (abs_path) { free(abs_path); abs_path = NULL; } return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (recursive_get_max_lengths(strlen(abs_path), folderid, filters, oDB, &max_lengths, &max_lengths_size, NULL, 1)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Search error\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_SEARCH_ERROR); if (abs_path) { free(abs_path); abs_path = NULL; } if (filters) { free(filters); filters = NULL; } return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (recursive_search (abs_path, folderid, filters, oDB, max_lengths, max_lengths_size, NULL, NULL, 1, handle->operator_json, oph_json_is_objkey_printable(((OPH_SEARCH_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SEARCH_operator_handle *) handle->operator_handle)->objkeys_num, OPH_JSON_OBJKEY_SEARCH))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Search error\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_SEARCH_ERROR); if (abs_path) { free(abs_path); abs_path = NULL; } if (filters) { free(filters); filters = NULL; } if (max_lengths) { free(max_lengths); max_lengths = NULL; } return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (abs_path) { free(abs_path); abs_path = NULL; } if (filters) { free(filters); filters = NULL; } if (max_lengths) { free(max_lengths); max_lengths = 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_DELETECONTAINER_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_DELETECONTAINER_operator_handle*)handle->operator_handle)->oDB; int id_container = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container; int hidden = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->hidden; int delete_type = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->delete_type; char *container_name = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->container_input; char *cwd = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->cwd; char *user = ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->user; if(delete_type == OPH_DELETE_LOGIC_CODE) hidden = 0; //Check if user can operate on container and if container exists int permission = 0; int folder_id = 0; int container_exists = 0; //Check if input path exists if((oph_odb_fs_path_parsing("", cwd, &folder_id, NULL, oDB))) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "Path %s doesn't exists\n", cwd); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_CWD_ERROR, container_name, cwd ); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if((oph_odb_fs_check_folder_session(folder_id, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->sessionid, oDB, &permission)) || !permission){ //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work in this folder\n", user); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_DATACUBE_PERMISSION_ERROR, container_name, user ); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if(oph_odb_fs_retrieve_container_id_from_container_name(oDB, folder_id, container_name, hidden, &id_container)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Unknown input %s container\n", (hidden ? "hidden" : "visible")); logging(LOG_ERROR, __FILE__, __LINE__,id_container, OPH_LOG_OPH_DELETECONTAINER_NO_INPUT_CONTAINER, (hidden ? "hidden" : "visible"), container_name ); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container = id_container; if(delete_type == OPH_DELETE_PHYSIC_CODE){ if(oph_odb_fs_check_if_container_empty(oDB, id_container)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Input container isn't empty\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_DELETECONTAINER_CONTAINER_NOT_EMPTY, container_name ); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } //Remove also grid related to container dimensions if(oph_odb_dim_delete_from_grid_table(oDB, id_container)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while deleting grid related to container\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_GRID_DELETE_ERROR ); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } //Delete container and related dimensions/ dimension instances if(oph_odb_fs_delete_from_container_table(oDB, id_container)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while deleting input container\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_CONTAINER_DELETE_ERROR ); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } oph_odb_db_instance db_; oph_odb_db_instance *db = &db_; if (oph_dim_load_dim_dbinstance(db)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while loading dimension db paramters\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_DIM_LOAD ); oph_dim_unload_dim_dbinstance(db); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } if (oph_dim_connect_to_dbms(db->dbms_instance, 0)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while connecting to dimension dbms\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_DIM_CONNECT ); oph_dim_disconnect_from_dbms(db->dbms_instance); oph_dim_unload_dim_dbinstance(db); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } if (oph_dim_use_db_of_dbms(db->dbms_instance, db)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while opening dimension db\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_DIM_USE_DB ); oph_dim_disconnect_from_dbms(db->dbms_instance); oph_dim_unload_dim_dbinstance(db); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } char index_dimension_table_name[OPH_COMMON_BUFFER_LEN],label_dimension_table_name[OPH_COMMON_BUFFER_LEN]; snprintf(index_dimension_table_name,OPH_COMMON_BUFFER_LEN,OPH_DIM_TABLE_NAME_MACRO,((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container); snprintf(label_dimension_table_name,OPH_COMMON_BUFFER_LEN,OPH_DIM_TABLE_LABEL_MACRO,((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container); if (oph_dim_delete_table(db, index_dimension_table_name)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while deleting dimension table\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_DIM_TABLE_DELETE_ERROR ); oph_dim_disconnect_from_dbms(db->dbms_instance); oph_dim_unload_dim_dbinstance(db); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } if (oph_dim_delete_table(db, label_dimension_table_name)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error while deleting dimension table\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container, OPH_LOG_OPH_DELETECONTAINER_DIM_TABLE_DELETE_ERROR ); oph_dim_disconnect_from_dbms(db->dbms_instance); oph_dim_unload_dim_dbinstance(db); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } oph_dim_disconnect_from_dbms(db->dbms_instance); oph_dim_unload_dim_dbinstance(db); } else{ //Check if hidden container exists in folder if(oph_odb_fs_is_hidden_container(folder_id, container_name, oDB, &container_exists)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to check output container\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_DELETECONTAINER_OUTPUT_CONTAINER_ERROR_NO_CONTAINER, container_name, container_name ); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (container_exists) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Hidden container '%s' already exists in this folder\n", container_name); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_DELETECONTAINER_OUTPUT_CONTAINER_EXIST_ERROR, container_name, container_name ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //If container exists then DELETE if(oph_odb_fs_set_container_hidden_status(id_container, 1, oDB)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to delete logically container %s\n", container_name); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_DELETECONTAINER_UPDATE_CONTAINER_ERROR, container_name ); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } } 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_RESTORECONTAINER_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; char *container_name = ((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->container_output; int id_container_out = 0, container_exists = 0; ophidiadb *oDB = &((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->oDB; char *cwd = ((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->cwd; char *user = ((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->user; int permission = 0; int folder_id = 0; //Check if input path exists if ((oph_odb_fs_path_parsing("", cwd, &folder_id, NULL, oDB))) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "Path %s doesn't exists\n", cwd); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_RESTORECONTAINER_CWD_ERROR, container_name, cwd); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if ((oph_odb_fs_check_folder_session(folder_id, ((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->sessionid, oDB, &permission)) || !permission) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work in this folder\n", user); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_RESTORECONTAINER_DATACUBE_PERMISSION_ERROR, container_name, user); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if ((oph_odb_fs_retrieve_container_id_from_container_name(oDB, folder_id, container_name, 1, &id_container_out))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Output container doesn't exist or it isn't hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_RESTORECONTAINER_OUTPUT_CONTAINER_EXIST_ERROR_NO_CONTAINER, container_name, container_name); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (id_container_out) { ((OPH_RESTORECONTAINER_operator_handle *) handle->operator_handle)->id_output_container = id_container_out; //Check if non-hidden container exists in folder if ((oph_odb_fs_check_if_container_not_present(oDB, container_name, folder_id, &container_exists))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to check output container\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container_out, OPH_LOG_OPH_RESTORECONTAINER_OUTPUT_CONTAINER_ERROR_NO_CONTAINER, container_name, container_name); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if (container_exists) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Visible container '%s' already exists in this folder\n", container_name); logging(LOG_ERROR, __FILE__, __LINE__, id_container_out, OPH_LOG_OPH_RESTORECONTAINER_OUTPUT_CONTAINER_EXIST_ERROR, container_name, container_name); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //If container exists then restore if (oph_odb_fs_set_container_hidden_status(id_container_out, 0, oDB)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to update container table\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container_out, OPH_LOG_OPH_RESTORECONTAINER_UPDATE_CONTAINER_ERROR, container_name); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } } return OPH_ANALYTICS_OPERATOR_SUCCESS; }
int env_set(HASHTBL * task_tbl, oph_operator_struct * handle) { if (!handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n"); return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE; } if (!task_tbl) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null operator string\n"); return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } if (handle->operator_handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator handle already initialized\n"); return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE; } if (!(handle->operator_handle = (OPH_UNPUBLISH_operator_handle *) calloc(1, sizeof(OPH_UNPUBLISH_operator_handle)))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_UNPUBLISH_MEMORY_ERROR_HANDLE); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //1 - Set up struct to empty values ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->datacube_path = NULL; ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys = NULL; ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys_num = -1; ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->sessionid = NULL; //Only master process has to continue if (handle->proc_rank != 0) return OPH_ANALYTICS_OPERATOR_SUCCESS; ophidiadb *oDB = &((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->oDB; oph_odb_init_ophidiadb(oDB); char *datacube_name; int id_container = 0; char *value; // retrieve objkeys value = hashtbl_get(task_tbl, OPH_IN_PARAM_OBJKEY_FILTER); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_OBJKEY_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_OBJKEY_FILTER); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (oph_tp_parse_multiple_value_param(value, &((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys, &((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys_num)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Operator string not valid\n"); oph_tp_free_multiple_value_param_list(((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->objkeys_num); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } // retrieve sessionid value = hashtbl_get(task_tbl, OPH_ARG_SESSIONID); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_SESSIONID); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_ARG_SESSIONID); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (!(((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->sessionid = (char *) strndup(value, OPH_TP_TASKLEN))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_GENERIC_MEMORY_ERROR_INPUT, "sessionid"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //3 - Fill struct with the correct data char *tmp_username = NULL; value = hashtbl_get(task_tbl, OPH_ARG_USERNAME); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_USERNAME); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_UNPUBLISH_MISSING_INPUT_PARAMETER, OPH_ARG_USERNAME); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (!(tmp_username = (char *) strndup(value, OPH_TP_TASKLEN))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_UNPUBLISH_MEMORY_ERROR_INPUT, OPH_ARG_USERNAME); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_DATACUBE_INPUT); datacube_name = value; if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DATACUBE_INPUT); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_UNPUBLISH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_DATACUBE_INPUT); free(tmp_username); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } 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_UNPUBLISH_OPHIDIADB_CONFIGURATION_FILE); free(tmp_username); 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_UNPUBLISH_OPHIDIADB_CONNECTION_ERROR); free(tmp_username); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } int id_datacube = 0; //Check if datacube exists (by ID container and datacube) int exists = 0; char *uri = NULL; int folder_id = 0; int permission = 0; if (oph_pid_parse_pid(value, &id_container, &id_datacube, &uri)) { if (uri) free(uri); pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse the PID string\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_UNPUBLISH_PID_ERROR, datacube_name); free(tmp_username); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } if ((oph_odb_cube_check_if_datacube_not_present_by_pid(oDB, uri, id_container, id_datacube, &exists)) || !exists) { free(uri); pmesg(LOG_ERROR, __FILE__, __LINE__, "Unknown input container - datacube combination\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_UNPUBLISH_NO_INPUT_DATACUBE, datacube_name); free(tmp_username); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } if ((oph_odb_fs_retrive_container_folder_id(oDB, id_container, 1, &folder_id))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve folder of specified datacube or container is hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_UNPUBLISH_DATACUBE_FOLDER_ERROR, datacube_name); free(uri); free(tmp_username); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } if ((oph_odb_fs_check_folder_session(folder_id, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->sessionid, oDB, &permission)) || !permission) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work on this datacube\n", tmp_username); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_UNPUBLISH_DATACUBE_PERMISSION_ERROR, tmp_username); free(uri); free(tmp_username); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } free(tmp_username); free(uri); ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->id_input_container = id_container; char session_code[OPH_COMMON_BUFFER_LEN]; oph_pid_get_session_code(hashtbl_get(task_tbl, OPH_ARG_SESSIONID), session_code); int n = snprintf(NULL, 0, OPH_FRAMEWORK_HTML_FILES_PATH, oph_pid_path()? oph_pid_path() : OPH_PREFIX_CLUSTER, session_code, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->id_input_container, id_datacube) + 1; if (n >= OPH_TP_TASKLEN) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Size of path exceeded limit.\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_UNPUBLISH_STRING_BUFFER_OVERFLOW, "path", OPH_FRAMEWORK_HTML_FILES_PATH); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } if (!(((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->datacube_path = (char *) malloc(n * sizeof(char)))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_OPH_UNPUBLISH_MEMORY_ERROR_INPUT, "datacube path"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } snprintf(((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->datacube_path, n, OPH_FRAMEWORK_HTML_FILES_PATH, oph_pid_path()? oph_pid_path() : OPH_PREFIX_CLUSTER, session_code, ((OPH_UNPUBLISH_operator_handle *) handle->operator_handle)->id_input_container, id_datacube); return OPH_ANALYTICS_OPERATOR_SUCCESS; }
int env_set(HASHTBL * task_tbl, oph_operator_struct * handle) { if (!handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n"); return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE; } if (!task_tbl) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null operator string\n"); return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } if (handle->operator_handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator handle already initialized\n"); return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE; } if (!(handle->operator_handle = (OPH_SPLIT_operator_handle *) calloc(1, sizeof(OPH_SPLIT_operator_handle)))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SPLIT_MEMORY_ERROR_HANDLE); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //1 - Set up struct to empty values ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_input_datacube = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_output_datacube = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_input_container = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_output_container = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_job = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->fragment_ids = NULL; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys = NULL; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys_num = -1; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->server = NULL; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->sessionid = NULL; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_user = 0; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->description = NULL; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->execute_error = 0; char *datacube_in; char *value; // retrieve objkeys value = hashtbl_get(task_tbl, OPH_IN_PARAM_OBJKEY_FILTER); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_OBJKEY_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_OBJKEY_FILTER); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (oph_tp_parse_multiple_value_param(value, &((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys, &((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys_num)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Operator string not valid\n"); oph_tp_free_multiple_value_param_list(((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SPLIT_operator_handle *) handle->operator_handle)->objkeys_num); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } // retrieve sessionid value = hashtbl_get(task_tbl, OPH_ARG_SESSIONID); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_SESSIONID); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_ARG_SESSIONID); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (!(((OPH_SPLIT_operator_handle *) handle->operator_handle)->sessionid = (char *) strndup(value, OPH_TP_TASKLEN))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_GENERIC_MEMORY_ERROR_INPUT, "sessionid"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //3 - Fill struct with the correct data value = hashtbl_get(task_tbl, OPH_IN_PARAM_DATACUBE_INPUT); datacube_in = value; if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DATACUBE_INPUT); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SPLIT_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_DATACUBE_INPUT); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //For error checking int id_datacube_in[3] = { 0, 0, 0 }; value = hashtbl_get(task_tbl, OPH_ARG_USERNAME); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_USERNAME); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SPLIT_MISSING_INPUT_PARAMETER, OPH_ARG_USERNAME); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } char *username = value; if (handle->proc_rank == 0) { //Only master process has to initialize and open connection to management OphidiaDB ophidiadb *oDB = &((OPH_SPLIT_operator_handle *) handle->operator_handle)->oDB; oph_odb_init_ophidiadb(oDB); 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_SPLIT_OPHIDIADB_CONFIGURATION_FILE); 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_SPLIT_OPHIDIADB_CONNECTION_ERROR); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } //Check if datacube exists (by ID container and datacube) int exists = 0; int status = 0; char *uri = NULL; int folder_id = 0; int permission = 0; if (oph_pid_parse_pid(datacube_in, &id_datacube_in[1], &id_datacube_in[0], &uri)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse the PID string\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_PID_ERROR, datacube_in); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } else if ((oph_odb_cube_check_if_datacube_not_present_by_pid(oDB, uri, id_datacube_in[1], id_datacube_in[0], &exists)) || !exists) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unknown input container - datacube combination\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_NO_INPUT_DATACUBE, datacube_in); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } else if ((oph_odb_cube_check_datacube_availability(oDB, id_datacube_in[0], 0, &status)) || !status) { pmesg(LOG_ERROR, __FILE__, __LINE__, "I/O nodes storing datacube aren't available\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_DATACUBE_AVAILABILITY_ERROR, datacube_in); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } else if ((oph_odb_fs_retrive_container_folder_id(oDB, id_datacube_in[1], 1, &folder_id))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve folder of specified datacube or container is hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_DATACUBE_FOLDER_ERROR, datacube_in); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } else if ((oph_odb_fs_check_folder_session(folder_id, ((OPH_SPLIT_operator_handle *) handle->operator_handle)->sessionid, oDB, &permission)) || !permission) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work on this datacube\n", username); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_DATACUBE_PERMISSION_ERROR, username); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } if (uri) free(uri); uri = NULL; if (oph_odb_user_retrieve_user_id(oDB, username, &(((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_user))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to extract userid.\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_input_container, OPH_LOG_GENERIC_USER_ID_ERROR); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } id_datacube_in[2] = id_datacube_in[1]; if (id_datacube_in[1]) { value = hashtbl_get(task_tbl, OPH_IN_PARAM_CONTAINER_INPUT); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_CONTAINER_INPUT); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_CONTAINER_INPUT); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (strncmp(value, OPH_COMMON_DEFAULT_EMPTY_VALUE, OPH_TP_TASKLEN)) { if (oph_odb_fs_retrieve_container_id_from_container_name(oDB, folder_id, value, 0, &id_datacube_in[2])) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve folder of specified container or it is hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_GENERIC_DATACUBE_FOLDER_ERROR, value); id_datacube_in[0] = 0; id_datacube_in[1] = 0; } } } } //Broadcast to all other processes the fragment relative index MPI_Bcast(id_datacube_in, 3, MPI_INT, 0, MPI_COMM_WORLD); //Check if sequential part has been completed if (id_datacube_in[0] == 0) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Master procedure or broadcasting has failed\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_NO_INPUT_DATACUBE, datacube_in); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_input_datacube = id_datacube_in[0]; if (id_datacube_in[1] == 0) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Master procedure or broadcasting has failed\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_NO_INPUT_CONTAINER, datacube_in); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_input_container = id_datacube_in[1]; ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_output_container = id_datacube_in[2]; value = hashtbl_get(task_tbl, OPH_IN_PARAM_SCHEDULE_ALGORITHM); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_SCHEDULE_ALGORITHM); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_SCHEDULE_ALGORITHM); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } ((OPH_SPLIT_operator_handle *) handle->operator_handle)->schedule_algo = (int) strtol(value, NULL, 10); value = hashtbl_get(task_tbl, OPH_IN_PARAM_SPLIT_IN_FRAGMENTS); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_SPLIT_IN_FRAGMENTS); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_SPLIT_IN_FRAGMENTS); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } ((OPH_SPLIT_operator_handle *) handle->operator_handle)->split_number = (int) strtol(value, NULL, 10); value = hashtbl_get(task_tbl, OPH_ARG_IDJOB); if (!value) ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_job = 0; else ((OPH_SPLIT_operator_handle *) handle->operator_handle)->id_job = (int) strtol(value, NULL, 10); value = hashtbl_get(task_tbl, OPH_IN_PARAM_DESCRIPTION); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DESCRIPTION); logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_DESCRIPTION); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (strncmp(value, OPH_COMMON_DEFAULT_EMPTY_VALUE, OPH_TP_TASKLEN)) { if (!(((OPH_SPLIT_operator_handle *) handle->operator_handle)->description = (char *) strndup(value, OPH_TP_TASKLEN))) { logging(LOG_ERROR, __FILE__, __LINE__, id_datacube_in[1], OPH_LOG_OPH_SPLIT_MEMORY_ERROR_INPUT, "description"); pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } return OPH_ANALYTICS_OPERATOR_SUCCESS; }
int env_set(HASHTBL * task_tbl, oph_operator_struct * handle) { if (!handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null Handle\n"); return OPH_ANALYTICS_OPERATOR_NULL_OPERATOR_HANDLE; } if (!task_tbl) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Null operator string\n"); return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } if (handle->operator_handle) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator handle already initialized\n"); return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE; } if (!(handle->operator_handle = (OPH_CUBEIO_operator_handle *) calloc(1, sizeof(OPH_CUBEIO_operator_handle)))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR_HANDLE); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //1 - Set up struct to empty values ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->direction = 0; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container = 0; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_datacube = 0; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->datacube_name = NULL; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys = NULL; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys_num = -1; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->sessionid = NULL; ophidiadb *oDB = &((OPH_CUBEIO_operator_handle *) handle->operator_handle)->oDB; //Only master process has to continue if (handle->proc_rank != 0) return OPH_ANALYTICS_OPERATOR_SUCCESS; oph_odb_init_ophidiadb(oDB); //3 - Fill struct with the correct data char *datacube_name, *value; // retrieve objkeys value = hashtbl_get(task_tbl, OPH_IN_PARAM_OBJKEY_FILTER); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_OBJKEY_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_OBJKEY_FILTER); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (oph_tp_parse_multiple_value_param(value, &((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys, &((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys_num)) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Operator string not valid\n"); oph_tp_free_multiple_value_param_list(((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->objkeys_num); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } // retrieve sessionid value = hashtbl_get(task_tbl, OPH_ARG_SESSIONID); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_SESSIONID); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_ARG_SESSIONID); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (!(((OPH_CUBEIO_operator_handle *) handle->operator_handle)->sessionid = (char *) strndup(value, OPH_TP_TASKLEN))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_GENERIC_MEMORY_ERROR_INPUT, "sessionid"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_DATACUBE_INPUT); datacube_name = value; if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DATACUBE_INPUT); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_DATACUBE_INPUT); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } 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_CUBEIO_OPHIDIADB_CONFIGURATION_FILE); 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_CUBEIO_OPHIDIADB_CONNECTION_ERROR); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } value = hashtbl_get(task_tbl, OPH_ARG_USERNAME); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_USERNAME); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MISSING_INPUT_PARAMETER, OPH_ARG_USERNAME); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } char *username = value; int id_container = 0, id_datacube = 0; //Check if datacube exists (by ID container and datacube) int exists = 0; char *uri = NULL; int folder_id = 0; int permission = 0; if (oph_pid_parse_pid(datacube_name, &id_container, &id_datacube, &uri)) { if (uri) free(uri); pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse the PID string\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_CUBEIO_PID_ERROR, datacube_name); return OPH_ANALYTICS_OPERATOR_UTILITY_ERROR; } else if ((oph_odb_cube_check_if_datacube_not_present_by_pid(oDB, uri, id_container, id_datacube, &exists)) || !exists) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unknown input container - datacube combination\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_CUBEIO_NO_INPUT_DATACUBE, datacube_name); free(uri); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } else if ((oph_odb_fs_retrive_container_folder_id(oDB, id_container, 1, &folder_id))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve folder of specified datacube or container is hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_CUBEIO_DATACUBE_FOLDER_ERROR, datacube_name); free(uri); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } else if ((oph_odb_fs_check_folder_session(folder_id, ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->sessionid, oDB, &permission)) || !permission) { //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work on this datacube\n", username); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_CUBEIO_DATACUBE_PERMISSION_ERROR, username); free(uri); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } free(uri); ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_container = id_container; ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->id_input_datacube = id_datacube; if (!(((OPH_CUBEIO_operator_handle *) handle->operator_handle)->datacube_name = (char *) strndup(datacube_name, OPH_TP_TASKLEN))) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, id_container, OPH_LOG_OPH_CUBEIO_MEMORY_ERROR_INPUT, "datacube name"); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_CUBEIO_HIERARCHY_DIRECTION); if (!value) { pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_CUBEIO_HIERARCHY_DIRECTION); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_CUBEIO_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_CUBEIO_HIERARCHY_DIRECTION); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (strcmp(value, OPH_CUBEIO_PARENT_VALUE) == 0) ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->direction = OPH_CUBEIO_BRANCH_IN; else if (strcmp(value, OPH_CUBEIO_CHILDREN_VALUE) == 0) ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->direction = OPH_CUBEIO_BRANCH_OUT; else ((OPH_CUBEIO_operator_handle *) handle->operator_handle)->direction = OPH_CUBEIO_BRANCH_BOTH; return OPH_ANALYTICS_OPERATOR_SUCCESS; }
int env_set (HASHTBL *task_tbl, oph_operator_struct *handle) { if (!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; } if (!task_tbl){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Null operator string\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_NULL_TASK_TABLE); return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER; } if (handle->operator_handle){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator handle already initialized\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_HANDLE_ALREADY_INITIALIZED); return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE; } if (!(handle->operator_handle = (OPH_METADATA_operator_handle *) calloc (1, sizeof (OPH_METADATA_operator_handle)))){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_METADATA_MEMORY_ERROR_HANDLE); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } //1 - Set up struct to empty values ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_datacube_input = 0; ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input = 0; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_id = 0; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_id_str = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys_num = 0; ((OPH_METADATA_operator_handle*)handle->operator_handle)->variable = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_type = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_type_filter = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_value = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_value_filter = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->mode = -1; ((OPH_METADATA_operator_handle*)handle->operator_handle)->force = 0; ((OPH_METADATA_operator_handle*)handle->operator_handle)->user = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num = -1; ((OPH_METADATA_operator_handle*)handle->operator_handle)->sessionid = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->userrole = OPH_ROLE_NONE; ophidiadb *oDB = &((OPH_METADATA_operator_handle*)handle->operator_handle)->oDB; //Only master process has to continue if (handle->proc_rank != 0) return OPH_ANALYTICS_OPERATOR_SUCCESS; oph_odb_init_ophidiadb(oDB); 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_METADATA_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_METADATA_OPHIDIADB_CONNECTION_ERROR_NO_CONTAINER); return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR; } //3 - Fill struct with the correct data char *value; // retrieve objkeys value = hashtbl_get(task_tbl, OPH_IN_PARAM_OBJKEY_FILTER); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_OBJKEY_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_OBJKEY_FILTER ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(oph_tp_parse_multiple_value_param(value, &((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys, &((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Operator string not valid\n"); oph_tp_free_multiple_value_param_list(((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys, ((OPH_METADATA_operator_handle*)handle->operator_handle)->objkeys_num); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } // retrieve sessionid value = hashtbl_get(task_tbl, OPH_ARG_SESSIONID); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_SESSIONID); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_ARG_SESSIONID); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->sessionid = (char *) strndup (value, OPH_TP_TASKLEN))){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_GENERIC_MEMORY_ERROR_INPUT, "sessionid" ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_MODE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_MODE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_MODE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (!strcasecmp(value,OPH_METADATA_MODE_INSERT)) { ((OPH_METADATA_operator_handle*)handle->operator_handle)->mode = OPH_METADATA_MODE_INSERT_VALUE; } else if (!strcasecmp(value,OPH_METADATA_MODE_READ)) { ((OPH_METADATA_operator_handle*)handle->operator_handle)->mode = OPH_METADATA_MODE_READ_VALUE; } else if (!strcasecmp(value,OPH_METADATA_MODE_UPDATE)) { ((OPH_METADATA_operator_handle*)handle->operator_handle)->mode = OPH_METADATA_MODE_UPDATE_VALUE; } else if (!strcasecmp(value,OPH_METADATA_MODE_DELETE)) { ((OPH_METADATA_operator_handle*)handle->operator_handle)->mode = OPH_METADATA_MODE_DELETE_VALUE; } else { pmesg(LOG_ERROR, __FILE__, __LINE__, "Invalid input parameter %s\n", value); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INVALID_INPUT_PARAMETER, value ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //Check if user can access container and retrieve container id value = hashtbl_get(task_tbl, OPH_ARG_USERNAME); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_USERNAME); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_ARG_USERNAME ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->user = (char *) strdup(value))){ 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, OPH_ARG_USERNAME ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_DATACUBE_INPUT); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DATACUBE_INPUT); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_DATACUBE_INPUT ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //Check if datacube exists (by ID container and datacube) int exists = 0; int status = 0; int folder_id = 0; int permission = 0; char *uri = NULL; if(oph_pid_parse_pid(value, &(((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input), &(((OPH_METADATA_operator_handle*)handle->operator_handle)->id_datacube_input), &uri)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to parse the PID string\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, OPH_LOG_OPH_METADATA_PID_ERROR, value ); if(uri) free(uri); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } else if((oph_odb_cube_check_if_datacube_not_present_by_pid(oDB, uri, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_datacube_input, &exists)) || !exists){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Unknown input container - datacube combination\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, OPH_LOG_OPH_METADATA_NO_INPUT_DATACUBE, value ); if(uri) free(uri); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } else if((oph_odb_cube_check_datacube_availability(oDB, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_datacube_input, 0, &status)) || !status){ pmesg(LOG_ERROR, __FILE__, __LINE__, "I/O nodes storing datacube aren't available\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, OPH_LOG_OPH_METADATA_DATACUBE_AVAILABILITY_ERROR, value ); if(uri) free(uri); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } else if((oph_odb_fs_retrive_container_folder_id(oDB, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, 1, &folder_id))){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Unable to retrieve folder of specified datacube or container is hidden\n"); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, OPH_LOG_OPH_METADATA_DATACUBE_FOLDER_ERROR, value ); if(uri) free(uri); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } else if((oph_odb_fs_check_folder_session(folder_id, ((OPH_METADATA_operator_handle*)handle->operator_handle)->sessionid, oDB, &permission)) || !permission){ //Check if user can work on datacube pmesg(LOG_ERROR, __FILE__, __LINE__, "User %s is not allowed to work on this datacube\n", ((OPH_METADATA_operator_handle*)handle->operator_handle)->user); logging(LOG_ERROR, __FILE__, __LINE__, ((OPH_METADATA_operator_handle*)handle->operator_handle)->id_container_input, OPH_LOG_OPH_METADATA_DATACUBE_PERMISSION_ERROR, ((OPH_METADATA_operator_handle*)handle->operator_handle)->user ); if(uri) free(uri); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(uri) free(uri); uri = NULL; value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_KEY); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_KEY); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_KEY ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(oph_tp_parse_multiple_value_param(value, &((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys, &((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys_num)){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n"); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INVALID_INPUT_STRING); oph_tp_free_multiple_value_param_list(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys, ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys_num); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } //If first value supplied as key is ALL, then free the structure and set values to NULL and 0 if(strncmp(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys[0], OPH_COMMON_ALL_FILTER, strlen(OPH_COMMON_ALL_FILTER)) == 0){ oph_tp_free_multiple_value_param_list(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys, ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys_num); ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys = NULL; ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_keys_num = 0; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_ID); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_ID); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_ID ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_id_str = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_ID ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } ((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_id = (int)strtol(value,NULL,10); value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_VARIABLE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_VARIABLE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_VARIABLE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if (strcasecmp(value,OPH_COMMON_GLOBAL_VALUE)) { if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->variable = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_VARIABLE ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_TYPE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_TYPE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_TYPE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_type = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_TYPE ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_VALUE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_VALUE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_VALUE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(strncmp(value, OPH_COMMON_DEFAULT_EMPTY_VALUE, OPH_TP_TASKLEN) != 0){ if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_value = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_VALUE ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_TYPE_FILTER); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_TYPE_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_TYPE_FILTER ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(strcasecmp(value,OPH_COMMON_ALL_FILTER) != 0){ if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_type_filter = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_TYPE_FILTER ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } else { if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_type_filter = (char *) strdup("%"))){ 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, OPH_IN_PARAM_METADATA_TYPE_FILTER ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_VALUE_FILTER); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_VALUE_FILTER); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_VALUE_FILTER ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(strcasecmp(value,OPH_COMMON_ALL_FILTER) != 0){ if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_value_filter = (char *) strdup(value))){ 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, OPH_IN_PARAM_METADATA_VALUE_FILTER ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } else { if(!(((OPH_METADATA_operator_handle*)handle->operator_handle)->metadata_value_filter = (char *) strdup("%"))){ 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, OPH_IN_PARAM_METADATA_VALUE_FILTER ); return OPH_ANALYTICS_OPERATOR_MEMORY_ERR; } } value = hashtbl_get(task_tbl, OPH_IN_PARAM_FORCE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_FORCE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_FORCE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } if(strcmp(value,OPH_COMMON_YES_VALUE) == 0){ ((OPH_METADATA_operator_handle*)handle->operator_handle)->force = 1; } value = hashtbl_get(task_tbl, OPH_ARG_USERROLE); if(!value){ pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_ARG_USERROLE); logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MISSING_INPUT_PARAMETER, OPH_ARG_USERROLE ); return OPH_ANALYTICS_OPERATOR_INVALID_PARAM; } ((OPH_METADATA_operator_handle*)handle->operator_handle)->userrole = (int)strtol(value, NULL, 10); return OPH_ANALYTICS_OPERATOR_SUCCESS; }