int cl_host_alias_list_cleanup(cl_raw_list_t** list_p) {
cl_host_alias_list_elem_t* elem = NULL;
int ret_val = CL_RETVAL_OK;
if (list_p == NULL) {
/* we expect an address of an pointer */
return CL_RETVAL_PARAMS;
}
if (*list_p == NULL) {
/* we expect an initalized pointer */
return CL_RETVAL_PARAMS;
}
/* delete all entries in list */
cl_raw_list_lock(*list_p);
while ( (elem = cl_host_alias_list_get_first_elem(*list_p)) != NULL) {
cl_raw_list_remove_elem(*list_p, elem->raw_elem);
sge_free(&(elem->local_resolved_hostname));
sge_free(&(elem->alias_name));
sge_free(&elem);
}
cl_raw_list_unlock(*list_p);
ret_val = cl_raw_list_cleanup(list_p);
CL_LOG(CL_LOG_INFO,"host alias cleanup done");
return ret_val;
}
int cl_endpoint_list_cleanup(cl_raw_list_t** list_p) {
cl_endpoint_list_data_t* ldata = NULL;
cl_endpoint_list_elem_t* elem = NULL;
if (list_p == NULL) {
/* we expect an address of an pointer */
return CL_RETVAL_PARAMS;
}
if (*list_p == NULL) {
/* we expect an initalized pointer */
return CL_RETVAL_PARAMS;
}
/* delete all entries in list */
cl_raw_list_lock(*list_p);
while ( (elem = cl_endpoint_list_get_first_elem(*list_p)) != NULL) {
cl_raw_list_remove_elem(*list_p, elem->raw_elem);
cl_com_free_endpoint(&(elem->endpoint));
sge_free(&elem);
}
cl_raw_list_unlock(*list_p);
/* clean list private data */
ldata = (*list_p)->list_data;
if (ldata != NULL) {
if (ldata->ht != NULL) {
sge_htable_destroy(ldata->ht);
}
sge_free(&ldata);
}
(*list_p)->list_data = NULL;
return cl_raw_list_cleanup(list_p);
}
int cl_fd_list_cleanup(cl_raw_list_t **list_p) {
cl_fd_list_elem_t* elem = NULL;
elem = cl_fd_list_get_first_elem(*list_p);
if (elem != NULL) {
CL_LOG(CL_LOG_WARNING, "The list was NOT empty. Unregister all external file descriptors before cleanup next time, please");
}
while(elem){
cl_fd_list_unregister_fd(*list_p, elem, 1);
elem = cl_fd_list_get_next_elem(elem);
}
return cl_raw_list_cleanup(list_p);
}
int main(int argc, char **argv)
{
int test = 1;
int my_error = 0;
cl_raw_list_t* list = NULL;
cl_raw_list_t* log_list = NULL;
my_error = cl_log_list_setup(&log_list, "test_dummy", 0, CL_LOG_FLUSHED , NULL);
printf("log list setup: %s\n", cl_get_error_text(my_error));
cl_log_list_set_log_level(log_list,CL_LOG_DEBUG);
cl_raw_list_setup(&list, "dummy_list",1);
cl_raw_list_append_elem( list , (void*) &test);
printf("list entries: %ld\n", cl_raw_list_get_elem_count(list));
my_error = CL_LOG(CL_LOG_INFO,"hallo");
printf("log: %s\n", cl_get_error_text(my_error));
printf("log list entries: %ld\n", cl_raw_list_get_elem_count(log_list));
cl_raw_list_remove_elem( list , cl_raw_list_search_elem( list, (void*) &test) );
printf("list entries: %ld\n", cl_raw_list_get_elem_count(list));
my_error = cl_raw_list_cleanup(&list);
if ( my_error != CL_RETVAL_OK) {
printf("error cl_raw_list_cleanup() -> %s\n", cl_get_error_text(my_error));
exit(1);
}
while (argc>1) {
dummy(argv[argc-1]);
argc--;
}
cl_log_list_cleanup(&log_list);
return 0;
}
int cl_endpoint_list_setup(cl_raw_list_t** list_p,
char* list_name,
long entry_life_time,
long refresh_interval,
bool create_hash) {
int ret_val = CL_RETVAL_OK;
struct timeval now;
cl_endpoint_list_data_t* ldata = NULL;
ldata = (cl_endpoint_list_data_t*) malloc(sizeof(cl_endpoint_list_data_t));
if (ldata == NULL ) {
return CL_RETVAL_MALLOC;
}
gettimeofday(&now, NULL);
ldata->entry_life_time = entry_life_time;
ldata->refresh_interval = refresh_interval;
ldata->last_refresh_time = now.tv_sec;
if (ldata->entry_life_time == 0) {
CL_LOG(CL_LOG_INFO,"using default value for entry_life_time");
ldata->entry_life_time = CL_ENDPOINT_LIST_DEFAULT_LIFE_TIME;
}
if (ldata->refresh_interval == 0) {
CL_LOG(CL_LOG_INFO,"using default value for refresh_interval");
ldata->refresh_interval = CL_ENDPOINT_LIST_DEFAULT_REFRESH_TIME;
}
ret_val = cl_raw_list_setup(list_p,list_name, 1);
if (ret_val != CL_RETVAL_OK) {
sge_free(&ldata);
return ret_val;
}
/* create hashtable */
if (create_hash == true) {
ldata->ht = sge_htable_create(4, dup_func_string, hash_func_string, hash_compare_string);
if (ldata->ht == NULL) {
cl_raw_list_cleanup(list_p);
sge_free(&ldata);
return CL_RETVAL_MALLOC;
}
CL_LOG_INT(CL_LOG_INFO,"created hash table with size =", 4);
} else {
CL_LOG(CL_LOG_INFO,"created NO hash table!");
ldata->ht = NULL;
}
/* set private list data */
(*list_p)->list_data = ldata;
CL_LOG_INT(CL_LOG_INFO,"entry_life_time is: ", ldata->entry_life_time);
CL_LOG_INT(CL_LOG_INFO,"refresh_interval is:", ldata->refresh_interval);
return ret_val;
}
int cl_message_list_cleanup(cl_raw_list_t** list_p) { /* CR check */
return cl_raw_list_cleanup(list_p);
}
int cl_app_message_queue_cleanup(cl_raw_list_t** list_p) {
return cl_raw_list_cleanup(list_p);
}
int cl_host_list_setup(cl_raw_list_t** list_p,
char* list_name,
cl_host_resolve_method_t method,
char* host_alias_file,
char* local_domain_name,
unsigned long entry_life_time,
unsigned long entry_update_time,
unsigned long entry_reresolve_time,
cl_bool_t create_hash) {
int ret_val = CL_RETVAL_OK;
cl_host_list_data_t* ldata = NULL;
ldata = (cl_host_list_data_t*) malloc(sizeof(cl_host_list_data_t));
if (ldata == NULL ) {
return CL_RETVAL_MALLOC;
}
ldata->host_alias_file = NULL;
ldata->alias_file_changed = 0;
ldata->host_alias_list = NULL;
ldata->resolve_method = method;
ldata->entry_life_time = entry_life_time;
ldata->entry_update_time = entry_update_time;
ldata->entry_reresolve_time = entry_reresolve_time;
ldata->last_refresh_time = 0;
if (local_domain_name == NULL && method == CL_LONG) {
CL_LOG(CL_LOG_WARNING,"can't compare short host names without default domain when method is CL_LONG");
}
if (entry_life_time == 0) {
unsigned long help_value = 0;
help_value = cl_util_get_ulong_value(getenv("SGE_COMMLIB_HOST_LIST_LIFE_TIME"));
if (help_value > 0) {
CL_LOG(CL_LOG_INFO,"environment variable SGE_COMMLIB_HOST_LIST_LIFE_TIME is set");
ldata->entry_life_time = help_value;
} else {
CL_LOG(CL_LOG_INFO,"using default value for entry_life_time");
ldata->entry_life_time = CL_HOST_LIST_DEFAULT_LIFE_TIME;
}
}
if (entry_update_time == 0) {
unsigned long help_value = 0;
help_value = cl_util_get_ulong_value(getenv("SGE_COMMLIB_HOST_LIST_UPDATE_TIME"));
if (help_value > 0) {
CL_LOG(CL_LOG_INFO,"environment variable SGE_COMMLIB_HOST_LIST_UPDATE_TIME is set");
ldata->entry_update_time = help_value;
} else {
CL_LOG(CL_LOG_INFO,"using default value for entry_update_time");
ldata->entry_update_time = CL_HOST_LIST_DEFAULT_UPDATE_TIME;
}
}
if (entry_reresolve_time == 0) {
unsigned long help_value = 0;
help_value = cl_util_get_ulong_value(getenv("SGE_COMMLIB_HOST_LIST_RERESOLVE_TIME"));
if (help_value > 0) {
CL_LOG(CL_LOG_INFO,"environment variable SGE_COMMLIB_HOST_LIST_RERESOLVE_TIME is set");
ldata->entry_reresolve_time = help_value;
} else {
CL_LOG(CL_LOG_INFO,"using default value for entry_reresolve_time");
ldata->entry_reresolve_time = CL_HOST_LIST_DEFAULT_RERESOLVE_TIME;
}
}
if ( ldata->entry_life_time > CL_HOST_LIST_MAX_LIFE_TIME) {
CL_LOG_INT(CL_LOG_WARNING,"entry_life_time exceeds maximum of",CL_HOST_LIST_MAX_LIFE_TIME);
CL_LOG(CL_LOG_WARNING,"using default value for entry_life_time");
ldata->entry_life_time = CL_HOST_LIST_DEFAULT_LIFE_TIME;
}
if ( ldata->entry_update_time > CL_HOST_LIST_MAX_UPDATE_TIME) {
CL_LOG_INT(CL_LOG_WARNING,"entry_update_time exceeds maximum of",CL_HOST_LIST_MAX_UPDATE_TIME);
CL_LOG(CL_LOG_WARNING,"using default value for entry_update_time");
ldata->entry_update_time = CL_HOST_LIST_DEFAULT_UPDATE_TIME;
}
if ( ldata->entry_reresolve_time > CL_HOST_LIST_MAX_RERESOLVE_TIME) {
CL_LOG_INT(CL_LOG_WARNING,"entry_reresolve_time exceeds maximum of",CL_HOST_LIST_MAX_RERESOLVE_TIME);
CL_LOG(CL_LOG_WARNING,"using default value for entry_reresolve_time");
ldata->entry_reresolve_time = CL_HOST_LIST_DEFAULT_RERESOLVE_TIME;
}
if (ldata->entry_life_time <= ldata->entry_update_time || ldata->entry_life_time <= ldata->entry_reresolve_time) {
free(ldata);
CL_LOG(CL_LOG_ERROR,"entry_life_time must be >= entry_update_time and >= entry_reresolve_time");
cl_commlib_push_application_error(CL_LOG_ERROR, CL_RETVAL_PARAMS, "SGE_COMMLIB_HOST_LIST_LIFE_TIME must be >= SGE_COMMLIB_HOST_LIST_UPDATE_TIME and >= SGE_COMMLIB_HOST_LIST_RERESOLVE_TIME");
return CL_RETVAL_PARAMS;
}
if (ldata->entry_update_time <= ldata->entry_reresolve_time) {
free(ldata);
CL_LOG(CL_LOG_ERROR,"entry_update_time must be >= entry_reresolve_time");
cl_commlib_push_application_error(CL_LOG_ERROR, CL_RETVAL_PARAMS, "SGE_COMMLIB_HOST_LIST_UPDATE_TIME must be >= SGE_COMMLIB_HOST_LIST_RERESOLVE_TIME");
return CL_RETVAL_PARAMS;
}
ret_val = cl_host_alias_list_setup(&(ldata->host_alias_list), "host alias list");
if (ret_val != CL_RETVAL_OK) {
free(ldata);
CL_LOG(CL_LOG_ERROR,"error setting up host alias list");
return ret_val;
}
if (host_alias_file != NULL) {
ldata->host_alias_file = strdup(host_alias_file);
ldata->alias_file_changed = 1;
if (ldata->host_alias_file == NULL) {
free(ldata);
return CL_RETVAL_MALLOC;
}
} else {
ldata->host_alias_file = NULL;
}
if (local_domain_name != NULL) {
ldata->local_domain_name = strdup(local_domain_name);
if (ldata->local_domain_name == NULL) {
if (ldata->host_alias_file != NULL) {
free(ldata->host_alias_file);
}
free(ldata);
return CL_RETVAL_MALLOC;
}
} else {
ldata->local_domain_name = NULL;
}
ret_val = cl_raw_list_setup(list_p,list_name, 1);
if (ret_val != CL_RETVAL_OK) {
if (ldata->host_alias_file != NULL) {
free(ldata->host_alias_file);
}
if (ldata->local_domain_name != NULL) {
free(ldata->local_domain_name);
}
free(ldata);
return ret_val;
}
switch(ldata->resolve_method) {
case CL_SHORT:
CL_LOG(CL_LOG_INFO,"using short hostname for host compare operations");
break;
case CL_LONG:
CL_LOG(CL_LOG_INFO,"using long hostname for host compare operations");
break;
default:
CL_LOG(CL_LOG_WARNING,"undefined resolving method");
break;
}
if (ldata->host_alias_file != NULL) {
CL_LOG_STR(CL_LOG_INFO,"using host alias file:", ldata->host_alias_file);
} else {
CL_LOG(CL_LOG_INFO,"no host alias file specified");
}
if (ldata->local_domain_name != NULL) {
CL_LOG_STR(CL_LOG_INFO,"using local domain name:", ldata->local_domain_name);
} else {
CL_LOG(CL_LOG_INFO,"no local domain specified");
}
/* create hashtable */
if (create_hash == CL_TRUE) {
ldata->ht = sge_htable_create(4, dup_func_string, hash_func_string, hash_compare_string);
if (ldata->ht == NULL) {
cl_raw_list_cleanup(list_p);
if (ldata->host_alias_file != NULL) {
free(ldata->host_alias_file);
}
if (ldata->local_domain_name != NULL) {
free(ldata->local_domain_name);
}
free(ldata);
return CL_RETVAL_MALLOC;
}
CL_LOG_INT(CL_LOG_INFO,"created hash table with size =", 4);
} else {
CL_LOG(CL_LOG_INFO,"created NO hash table!");
ldata->ht = NULL;
}
/* set private list data */
(*list_p)->list_data = ldata;
CL_LOG_INT(CL_LOG_INFO,"entry_life_time is", (int)ldata->entry_life_time);
CL_LOG_INT(CL_LOG_INFO,"entry_update_time is", (int)ldata->entry_update_time);
CL_LOG_INT(CL_LOG_INFO,"entry_reresolve_time is", (int)ldata->entry_reresolve_time);
return ret_val;
}
