/*
* this function frees all cached connections, including in-use ones.
*
* potential problems:
* - connections which are currently in-use are freed too.
* - connections which are uncached are NOT freed.
* i.e. the followings are all NOT freed:
* - connections which have never cached,
* - connections which had been once cached but currently uncached
* (since their network connections were dead)
*/
void
gfp_cached_connection_terminate(struct gfp_conn_cache *cache)
{
struct gfarm_hash_iterator it;
struct gfarm_hash_entry *entry;
struct gfp_cached_connection *connection;
static const char diag[] = "gfp_cached_connection_terminate";
gfarm_mutex_lock(&cache->mutex, diag, diag_what);
if (cache->hashtab == NULL) {
gfarm_mutex_unlock(&cache->mutex, diag, diag_what);
return;
}
gfarm_mutex_unlock(&cache->mutex, diag, diag_what);
/*
* clear all free connections.
* to makes cache->lru_list.free_cached_entries 0.
*/
gfp_cached_connection_gc_all(cache);
gfarm_mutex_lock(&cache->mutex, diag, diag_what);
/* clear all in-use connections too. XXX really necessary? */
for (gfarm_hash_iterator_begin(cache->hashtab, &it);
!gfarm_hash_iterator_is_end(&it);) {
entry = gfarm_hash_iterator_access(&it);
connection = *(struct gfp_cached_connection **)
gfarm_hash_entry_data(entry);
gfarm_lru_cache_purge_entry(&connection->lru_entry);
gfp_conn_hash_iterator_purge(&it);
gfarm_mutex_unlock(&cache->mutex, diag, diag_what);
(*cache->dispose_connection)(connection->connection_data);
gfarm_mutex_lock(&cache->mutex, diag, diag_what);
/* restart from the top, because maybe changed by others */
gfarm_hash_iterator_begin(cache->hashtab, &it);
}
/* free hash table */
gfarm_hash_table_free(cache->hashtab);
cache->hashtab = NULL;
gfarm_mutex_unlock(&cache->mutex, diag, diag_what);
}
static char *
hosts_for_program(char *program,
int *n_all_hostsp, struct gfarm_host_info **all_hostsp,
struct gfarm_hash_table **hosts_statep, int *n_runnable_hostsp)
{
char *e;
int n_all_hosts, n_runnable_hosts;
struct gfarm_host_info *all_hosts;
struct gfarm_hash_table *hosts_state;
struct gfarm_hash_table *arch_set;
struct gfarm_hash_iterator it;
struct gfarm_hash_entry *entry;
struct search_idle_host_state *h;
e = alloc_hosts_state(&n_all_hosts, &all_hosts, &hosts_state);
if (e == NULL) {
e = program_arch_set(program, &arch_set);
if (e == NULL) {
n_runnable_hosts = 0;
for (gfarm_hash_iterator_begin(hosts_state, &it);
!gfarm_hash_iterator_is_end(&it);
gfarm_hash_iterator_next(&it)) {
entry = gfarm_hash_iterator_access(&it);
h = gfarm_hash_entry_data(entry);
if (IS_IN_ARCH_SET(h->host_info->architecture,
arch_set)) {
h->flags |= HOST_STATE_FLAG_RUNNABLE;
++n_runnable_hosts;
}
}
free_arch_set(arch_set);
if (n_runnable_hosts > 0) {
*n_all_hostsp = n_all_hosts;
*all_hostsp = all_hosts;
*hosts_statep = hosts_state;
*n_runnable_hostsp = n_runnable_hosts;
return (NULL);
}
e = "there is no host which can run the program";
}
free_hosts_state(n_all_hosts, all_hosts, hosts_state);
}
return (e);
}
static gfarm_error_t
gfarm_hash_to_string_array(struct gfarm_hash_table *hash,
int *array_lengthp, char ***arrayp)
{
struct gfarm_hash_iterator iter;
struct gfarm_hash_entry *entry;
gfarm_stringlist ls;
char *ent, **array;
gfarm_error_t e;
e = gfarm_stringlist_init(&ls);
if (e != GFARM_ERR_NO_ERROR)
return (e);
for (gfarm_hash_iterator_begin(hash, &iter);
!gfarm_hash_iterator_is_end(&iter);
gfarm_hash_iterator_next(&iter)) {
entry = gfarm_hash_iterator_access(&iter);
if (entry != NULL) {
ent = strdup(gfarm_hash_entry_key(entry));
if (ent == NULL)
e = GFARM_ERR_NO_MEMORY;
else
e = gfarm_stringlist_add(&ls, ent);
}
if (e != GFARM_ERR_NO_ERROR)
goto stringlist_free;
}
array = gfarm_strings_alloc_from_stringlist(&ls);
if (array == NULL) {
e = GFARM_ERR_NO_MEMORY;
goto stringlist_free;
}
*array_lengthp = gfarm_stringlist_length(&ls);
*arrayp = array;
stringlist_free:
if (e == GFARM_ERR_NO_ERROR)
gfarm_stringlist_free(&ls);
else
gfarm_stringlist_free_deeply(&ls);
return (e);
}
