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_PRIMITIVES_LIST_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_PRIMITIVES_LIST_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_PRIMITIVES_LIST_HANDLE_ALREADY_INITIALIZED);
return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE;
}
if (!(handle->operator_handle = (OPH_PRIMITIVES_LIST_operator_handle *) calloc(1, sizeof(OPH_PRIMITIVES_LIST_operator_handle)))) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MEMORY_ERROR_HANDLE);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//1 - Set up struct to empty values
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->level = 0;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_ret = NULL;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_type = NULL;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->name_filter = NULL;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->limit = 0;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->id_dbms = 0;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->server = NULL;
ophidiadb *oDB = &((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->oDB;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys = NULL;
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys_num = -1;
//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 *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_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys, &((OPH_PRIMITIVES_LIST_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_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys,
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->objkeys_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_PRIMITIVE_NAME_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_PRIMITIVE_NAME_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_PRIMITIVE_NAME_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->name_filter = (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_PRIMITIVES_LIST_MEMORY_ERROR_INPUT, "name_filter");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_LIMIT_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_LIMIT_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_LIMIT_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->limit = (int) strtol(value, NULL, 10);
if (((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->limit < 0) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Limit must be positive\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_BAD_LIMIT, OPH_IN_PARAM_LIMIT_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_VISUALIZZATION_LEVEL);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_VISUALIZZATION_LEVEL);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_VISUALIZZATION_LEVEL);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->level = (int) strtol(value, NULL, 10);
if (((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->level < 1 || ((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->level > 5) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "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;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_DBMS_ID_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DBMS_ID_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_DBMS_ID_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (strcmp(value, OPH_COMMON_DEFAULT_EMPTY_VALUE) == 0) {
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->id_dbms = 0;
} else {
((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->id_dbms = (int) strtol(value, NULL, 10);
if (((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->id_dbms < 1) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "id of dbms must be positive\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_BAD_LIMIT, OPH_IN_PARAM_DBMS_ID_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_PRIMITIVE_RETURN_TYPE_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_PRIMITIVE_RETURN_TYPE_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_PRIMITIVE_RETURN_TYPE_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (strcmp(value, OPH_COMMON_ALL_FILTER) != 0) {
if (!(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_ret = (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_PRIMITIVES_LIST_MEMORY_ERROR_INPUT, "func_ret");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_PRIMITIVE_TYPE_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_PRIMITIVE_TYPE_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_PRIMITIVES_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_PRIMITIVE_TYPE_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (strcmp(value, OPH_COMMON_ALL_FILTER) != 0) {
if (!(((OPH_PRIMITIVES_LIST_operator_handle *) handle->operator_handle)->func_type = (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_PRIMITIVES_LIST_MEMORY_ERROR_INPUT, "func_type");
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");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_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_SEARCH_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_SEARCH_HANDLE_ALREADY_INITIALIZED);
return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE;
}
if (!(handle->operator_handle = (OPH_SEARCH_operator_handle *) calloc(1, sizeof(OPH_SEARCH_operator_handle)))) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MEMORY_ERROR_HANDLE);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//1 - Set up struct to empty values
((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter_num = 0;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->cwd = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter_num = 0;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter_num = 0;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->path = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->user = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->objkeys = NULL;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->objkeys_num = -1;
((OPH_SEARCH_operator_handle *) handle->operator_handle)->sessionid = NULL;
ophidiadb *oDB = &((OPH_SEARCH_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_SEARCH_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_SEARCH_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_SEARCH_operator_handle *) handle->operator_handle)->objkeys, &((OPH_SEARCH_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_SEARCH_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SEARCH_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_SEARCH_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_PATH);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_PATH);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_PATH);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SEARCH_operator_handle *) handle->operator_handle)->path = (char *) strdup(value))) {
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, OPH_IN_PARAM_PATH);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_CWD);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_CWD);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_CWD);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SEARCH_operator_handle *) handle->operator_handle)->cwd = (char *) strdup(value))) {
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, OPH_IN_PARAM_CWD);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_CONTAINER_NAME_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_CONTAINER_NAME_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_CONTAINER_NAME_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_tp_parse_multiple_value_param
(value, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter_num)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_INVALID_INPUT_STRING);
oph_tp_free_multiple_value_param_list(((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter,
((OPH_SEARCH_operator_handle *) handle->operator_handle)->container_filter_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_METADATA_KEY_FILTER);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_METADATA_KEY_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_KEY_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_tp_parse_multiple_value_param
(value, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter_num)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_INVALID_INPUT_STRING);
oph_tp_free_multiple_value_param_list(((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter,
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_key_filter_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
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_SEARCH_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_METADATA_VALUE_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_tp_parse_multiple_value_param
(value, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter, &((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter_num)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Operator string not valid\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SEARCH_INVALID_INPUT_STRING);
oph_tp_free_multiple_value_param_list(((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter,
((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
int i;
for (i = 0; i < ((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter_num; ++i)
if (strstr(((OPH_SEARCH_operator_handle *) handle->operator_handle)->metadata_value_filter[i], OPH_SEARCH_AND_SEPARATOR)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Separator '%s' cannot be used in filter for values: use it in filter for keys as 'AND'\n", OPH_SEARCH_AND_SEPARATOR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, "Separator '%s' cannot be used in filter for values: use it in filter for keys as 'AND'\n",
OPH_SEARCH_AND_SEPARATOR);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
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_SEARCH_MISSING_INPUT_PARAMETER, OPH_ARG_USERNAME);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SEARCH_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_SEARCH_MEMORY_ERROR_INPUT, OPH_ARG_USERNAME);
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_DELETECONTAINER_operator_handle *) calloc (1, sizeof (OPH_DELETECONTAINER_operator_handle)))){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_MEMORY_ERROR_HANDLE );
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//1 - Set up struct to empty values
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->id_input_container = 0;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->container_input = NULL;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->cwd = NULL;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->user = NULL;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->hidden = 0;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->delete_type = 0;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->objkeys = NULL;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->objkeys_num = -1;
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->sessionid = NULL;
ophidiadb *oDB = &((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->oDB;
oph_odb_init_ophidiadb(oDB);
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
//3 - Fill struct with the correct data
char *container_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_DELETECONTAINER_operator_handle*)handle->operator_handle)->objkeys, &((OPH_DELETECONTAINER_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_DELETECONTAINER_operator_handle*)handle->operator_handle)->objkeys, ((OPH_DELETECONTAINER_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_DELETECONTAINER_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;
}
container_name = (!hashtbl_get(task_tbl, OPH_IN_PARAM_CONTAINER_INPUT) ? "NO-CONTAINER" : hashtbl_get(task_tbl, OPH_IN_PARAM_CONTAINER_INPUT));
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__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_MISSING_INPUT_PARAMETER, container_name, OPH_IN_PARAM_CONTAINER_INPUT );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if(!(((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->container_input = (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_DELETECONTAINER_MEMORY_ERROR_INPUT_NO_CONTAINER, container_name, "container output name" );
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_CWD);
if(!value){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_CWD);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_MISSING_INPUT_PARAMETER, container_name, OPH_IN_PARAM_CWD );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if(!(((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->cwd = (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_DELETECONTAINER_MEMORY_ERROR_INPUT_NO_CONTAINER, container_name, "input path" );
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
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_DELETECONTAINER_MISSING_INPUT_PARAMETER, container_name, OPH_ARG_USERNAME );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if(!(((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->user = (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_DELETECONTAINER_MEMORY_ERROR_INPUT_NO_CONTAINER, container_name, "username" );
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_DELETE_TYPE);
if(!value){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_DELETE_TYPE);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_MISSING_INPUT_PARAMETER, container_name, OPH_IN_PARAM_DELETE_TYPE );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if( !strcmp(value, OPH_DELETE_PHYSIC_TYPE) ){
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->delete_type = OPH_DELETE_PHYSIC_CODE;
}
else{
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->delete_type = OPH_DELETE_LOGIC_CODE;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_HIDDEN);
if(!value){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_HIDDEN);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_DELETECONTAINER_MISSING_INPUT_PARAMETER, container_name, OPH_IN_PARAM_HIDDEN );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if( !strcmp(value, OPH_COMMON_NO_VALUE) ){
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->hidden = 0;
}
else{
((OPH_DELETECONTAINER_operator_handle*)handle->operator_handle)->hidden = 1;
}
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_DELETECONTAINER_OPHIDIADB_CONFIGURATION_FILE, container_name );
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_DELETECONTAINER_OPHIDIADB_CONNECTION_ERROR, container_name );
return OPH_ANALYTICS_OPERATOR_MYSQL_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_SCRIPT_operator_handle *) calloc(1, sizeof(OPH_SCRIPT_operator_handle)))) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Error allocating memory\n");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MEMORY_ERROR_HANDLE);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//1 - Set up struct to empty values
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args_num = -1;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->out_redir = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->err_redir = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys_num = -1;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->marker_id = NULL;
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->list = 0;
//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_SCRIPT_operator_handle *) handle->operator_handle)->objkeys, &((OPH_SCRIPT_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_SCRIPT_operator_handle *) handle->operator_handle)->objkeys, ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->objkeys_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_SCRIPT);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_SCRIPT);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_SCRIPT);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->script = (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_SCRIPT_MEMORY_ERROR_INPUT, "script");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_ARGS);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_ARGS);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_FRAMEWORK_MISSING_INPUT_PARAMETER, OPH_IN_PARAM_ARGS);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (oph_tp_parse_multiple_value_param(value, &((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args, &((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args_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_SCRIPT_operator_handle *) handle->operator_handle)->args, ((OPH_SCRIPT_operator_handle *) handle->operator_handle)->args_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_STDOUT);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_STDOUT);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_STDOUT);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->out_redir = (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_SCRIPT_MEMORY_ERROR_INPUT, "stdout");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_STDERR);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_STDERR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_STDERR);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->err_redir = (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_SCRIPT_MEMORY_ERROR_INPUT, "stderr");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_LIST);
if (!value) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_LIST);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_SCRIPT_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_LIST);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if (strncmp(value, OPH_COMMON_YES_VALUE, OPH_TP_TASKLEN) == 0) {
((OPH_SCRIPT_operator_handle *) handle->operator_handle)->list = 1;
}
char session_code[OPH_COMMON_BUFFER_LEN];
oph_pid_get_session_code(hashtbl_get(task_tbl, OPH_ARG_SESSIONID), session_code);
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_code = (char *) strdup(session_code))) {
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, "session code");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
char buff[OPH_COMMON_BUFFER_LEN];
snprintf(buff, OPH_COMMON_BUFFER_LEN, OPH_FRAMEWORK_MISCELLANEA_FILES_PATH, oph_pid_path()? oph_pid_path() : OPH_PREFIX_CLUSTER, session_code);
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_path = (char *) strdup(buff))) {
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, "session path");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
snprintf(buff, OPH_COMMON_BUFFER_LEN, OPH_FRAMEWORK_MISCELLANEA_FILES_PATH, oph_pid_uri(), session_code);
if (!(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->session_url = (char *) strdup(buff))) {
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, "session url");
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_ARG_WORKFLOWID);
if (value && !(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->workflow_id = (char *) strdup(value))) {
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, OPH_ARG_WORKFLOWID);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_ARG_MARKERID);
if (value && !(((OPH_SCRIPT_operator_handle *) handle->operator_handle)->marker_id = (char *) strdup(value))) {
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, OPH_ARG_MARKERID);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_ARG_USERNAME);
if (value && !(((OPH_SCRIPT_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_SCRIPT_MEMORY_ERROR_INPUT, OPH_ARG_USERNAME);
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_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");
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_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_OPERATORS_LIST_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_OPERATORS_LIST_HANDLE_ALREADY_INITIALIZED);
return OPH_ANALYTICS_OPERATOR_NOT_NULL_OPERATOR_HANDLE;
}
if (!(handle->operator_handle = (OPH_OPERATORS_LIST_operator_handle *) calloc (1, sizeof (OPH_OPERATORS_LIST_operator_handle)))){
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_HANDLE);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//1 - Set up struct to empty values
((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->name_filter = NULL;
((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->limit = 0;
((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys = NULL;
((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys_num = -1;
//Only master process has to continue
if (handle->proc_rank != 0)
return OPH_ANALYTICS_OPERATOR_SUCCESS;
//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_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys, &((OPH_OPERATORS_LIST_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_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys, ((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->objkeys_num);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_OPERATOR_NAME_FILTER);
if(!value){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_OPERATOR_NAME_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_OPERATOR_NAME_FILTER );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
if(!(((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->name_filter = (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_OPERATORS_LIST_MEMORY_ERROR_INPUT, "name_filter" );
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
value = hashtbl_get(task_tbl, OPH_IN_PARAM_LIMIT_FILTER);
if(!value){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Missing input parameter %s\n", OPH_IN_PARAM_LIMIT_FILTER);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_OPERATORS_LIST_MISSING_INPUT_PARAMETER, "NO-CONTAINER", OPH_IN_PARAM_LIMIT_FILTER );
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->limit = strtol(value,NULL,10);
if(((OPH_OPERATORS_LIST_operator_handle*)handle->operator_handle)->limit < 0){
pmesg(LOG_ERROR, __FILE__, __LINE__, "Limit must be positive\n");
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_OPH_OPERATORS_LIST_POSITIVE_LIMIT, OPH_IN_PARAM_LIMIT_FILTER);
return OPH_ANALYTICS_OPERATOR_INVALID_PARAM;
}
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 oph_metadata_crud(OPH_METADATA_operator_handle *handle, MYSQL_RES **read_result)
{
*read_result = NULL;
ophidiadb *oDB = &((OPH_METADATA_operator_handle*)handle)->oDB;
//Fill and execute the appropriate query
switch (handle->mode) {
case OPH_METADATA_MODE_INSERT_VALUE:
{
if (!IS_OPH_ROLE_PRESENT(handle->userrole,OPH_ROLE_WRITE_POS)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "At least \"%s\" permission is needed for this particular operation\n",OPH_ROLE_WRITE_STR);
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_GENERIC_INVALID_USERROLE_ERROR,OPH_ROLE_WRITE_STR);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
int idkey,idtype,iduser,idmetadatainstance;
if( !handle->metadata_keys || !handle->metadata_value){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_INSERT_INSTANCE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INSERT_INSTANCE_ERROR);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//retrieve type id
if(oph_odb_meta_retrieve_metadatatype_id(oDB, handle->metadata_type, &idtype)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_TYPE_ID_ERROR,handle->metadata_type);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_TYPE_ID_ERROR,handle->metadata_type);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
//Retrieve user id
if(oph_odb_user_retrieve_user_id(oDB, handle->user, &iduser)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_USER_ID_ERROR,handle->user);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_USER_ID_ERROR,handle->user);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
char** metadata_values = NULL;
int i, metadata_values_num = 0;
if (handle->metadata_keys_num>1)
{
if(oph_tp_parse_multiple_value_param(handle->metadata_value, &metadata_values, &metadata_values_num))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_VALUE_ERROR, handle->metadata_value);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_VALUE_ERROR, handle->metadata_value);
oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
if (handle->metadata_keys_num != metadata_values_num)
{
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_VALUE_ERROR, handle->metadata_value);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_VALUE_ERROR, handle->metadata_value);
oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
}
for (i=0;i<handle->metadata_keys_num;++i)
{
//retrieve key id
if(oph_odb_meta_retrieve_metadatakey_id(oDB, handle->metadata_keys[i], handle->variable, handle->id_container_input, 1, &idkey)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_KEY_ID_ERROR,handle->metadata_keys[i]);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_KEY_ID_ERROR,handle->metadata_keys[i]);
if (handle->metadata_keys_num>1) oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
//insert into medatainstance table
if(oph_odb_meta_insert_into_metadatainstance_table(oDB, handle->id_datacube_input, idkey, idtype, handle->metadata_keys_num>1 ? metadata_values[i] : handle->metadata_value, &idmetadatainstance)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_INSERT_INSTANCE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INSERT_INSTANCE_ERROR);
if (handle->metadata_keys_num>1) oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//insert into manage table
if(oph_odb_meta_insert_into_manage_table(oDB, idmetadatainstance, iduser)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_INSERT_MANAGE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INSERT_MANAGE_ERROR);
if (handle->metadata_keys_num>1) oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
}
if (handle->metadata_keys_num>1) oph_tp_free_multiple_value_param_list(metadata_values, metadata_values_num);
break;
}
case OPH_METADATA_MODE_READ_VALUE:
{
char *id_metadatainstance = NULL;
if (handle->metadata_id >0 ) { //read one or more metadata with filters
id_metadatainstance = handle->metadata_id_str;
}
if(oph_odb_meta_find_complete_metadata_list(oDB, handle->id_datacube_input, (const char **)handle->metadata_keys, handle->metadata_keys_num, id_metadatainstance, handle->metadata_type_filter, handle->metadata_value_filter, read_result)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_READ_METADATA_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_READ_METADATA_ERROR);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
break;
}
case OPH_METADATA_MODE_UPDATE_VALUE:
{
if (!IS_OPH_ROLE_PRESENT(handle->userrole,OPH_ROLE_WRITE_POS)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "At least \"%s\" permission is needed for this particular operation\n",OPH_ROLE_WRITE_STR);
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_GENERIC_INVALID_USERROLE_ERROR,OPH_ROLE_WRITE_STR);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
int iduser = 0, exists = 0;
if( !handle->metadata_id || !handle->metadata_value){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_UPDATE_INSTANCE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_UPDATE_INSTANCE_ERROR);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//Check metadata instance id
if(oph_odb_meta_check_metadatainstance_existance(oDB, handle->metadata_id, handle->id_datacube_input, &exists) || !exists){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_METADATAINSTANCE_FORCE_ERROR,handle->metadata_id);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_METADATAINSTANCE_FORCE_ERROR,handle->metadata_id);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
//Retrieve user id
if(oph_odb_user_retrieve_user_id(oDB, handle->user, &iduser)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_RETRIEVE_USER_ID_ERROR,handle->user);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_RETRIEVE_USER_ID_ERROR,handle->user);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
//update medatainstance table
if(oph_odb_meta_update_metadatainstance_table(oDB, handle->metadata_id, handle->id_datacube_input, handle->metadata_value, handle->force)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_UPDATE_INSTANCE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_UPDATE_INSTANCE_ERROR);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
//insert into manage table
if(oph_odb_meta_insert_into_manage_table(oDB, handle->metadata_id, iduser)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_INSERT_MANAGE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_INSERT_MANAGE_ERROR);
return OPH_ANALYTICS_OPERATOR_MEMORY_ERR;
}
break;
}
case OPH_METADATA_MODE_DELETE_VALUE:
{
if (!IS_OPH_ROLE_PRESENT(handle->userrole,OPH_ROLE_WRITE_POS)) {
pmesg(LOG_ERROR, __FILE__, __LINE__, "At least \"%s\" permission is needed for this particular operation\n",OPH_ROLE_WRITE_STR);
logging(LOG_ERROR,__FILE__,__LINE__, OPH_GENERIC_CONTAINER_ID,OPH_LOG_GENERIC_INVALID_USERROLE_ERROR,OPH_ROLE_WRITE_STR);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
if(oph_odb_meta_delete_from_metadatainstance_table(oDB, handle->id_datacube_input, (const char **)handle->metadata_keys, handle->metadata_keys_num, handle->metadata_id, handle->force)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_LOG_OPH_METADATA_DELETE_INSTANCE_ERROR);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_DELETE_INSTANCE_ERROR);
return OPH_ANALYTICS_OPERATOR_MYSQL_ERROR;
}
break;
}
default:
pmesg(LOG_ERROR, __FILE__, __LINE__,OPH_LOG_OPH_METADATA_MODE_ERROR, handle->mode);
logging(LOG_ERROR, __FILE__, __LINE__, OPH_GENERIC_CONTAINER_ID, OPH_LOG_OPH_METADATA_MODE_ERROR, handle->mode);
return OPH_ANALYTICS_OPERATOR_BAD_PARAMETER;
}
//End of query processing
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;
}
