static apr_status_t kill_dbi(void *p)
{
apr_status_t rv = APR_SUCCESS;
apr_hash_index_t *idx;
char *key;
ftpd_dbi_config *val;
apr_ssize_t len;
for (idx = apr_hash_first((apr_pool_t *) p, ftpd_dbi_config_hash); idx;
idx = apr_hash_next(idx)) {
apr_hash_this(idx, (void *) &key, &len, (void *) &val);
apr_reslist_destroy(val->pool);
}
dbi_shutdown();
return rv;
}
static void test_reslist(abts_case *tc, void *data)
{
int i;
apr_status_t rv;
apr_reslist_t *rl;
my_parameters_t *params;
apr_thread_pool_t *thrp;
my_thread_info_t thread_info[CONSUMER_THREADS];
rv = apr_thread_pool_create(&thrp, CONSUMER_THREADS/2, CONSUMER_THREADS, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Create some parameters that will be passed into each
* constructor and destructor call. */
params = apr_pcalloc(p, sizeof(*params));
params->sleep_upon_construct = CONSTRUCT_SLEEP_TIME;
params->sleep_upon_destruct = DESTRUCT_SLEEP_TIME;
/* We're going to want 10 blocks of data from our target rmm. */
rv = apr_reslist_create(&rl, RESLIST_MIN, RESLIST_SMAX, RESLIST_HMAX,
RESLIST_TTL, my_constructor, my_destructor,
params, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
for (i = 0; i < CONSUMER_THREADS; i++) {
thread_info[i].tid = i;
thread_info[i].tc = tc;
thread_info[i].reslist = rl;
thread_info[i].work_delay_sleep = WORK_DELAY_SLEEP_TIME;
rv = apr_thread_pool_push(thrp, resource_consuming_thread,
&thread_info[i], 0, NULL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
rv = apr_thread_pool_destroy(thrp);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
test_timeout(tc, rl);
test_shrinking(tc, rl);
ABTS_INT_EQUAL(tc, RESLIST_SMAX, params->c_count - params->d_count);
rv = apr_reslist_destroy(rl);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static apr_status_t test_reslist(apr_pool_t *parpool)
{
apr_status_t rv;
apr_pool_t *pool;
apr_reslist_t *rl;
my_parameters_t *params;
int i;
apr_thread_t *my_threads[CONSUMER_THREADS];
my_thread_info_t my_thread_info[CONSUMER_THREADS];
printf("Creating child pool.......................");
rv = apr_pool_create(&pool, parpool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Error creating child pool\n");
return rv;
}
printf("OK\n");
/* Create some parameters that will be passed into each
* constructor and destructor call. */
params = apr_pcalloc(pool, sizeof(*params));
params->sleep_upon_construct = CONSTRUCT_SLEEP_TIME;
params->sleep_upon_destruct = DESTRUCT_SLEEP_TIME;
/* We're going to want 10 blocks of data from our target rmm. */
printf("Creating resource list:\n"
" min/smax/hmax: %d/%d/%d\n"
" ttl: %" APR_TIME_T_FMT "\n", RESLIST_MIN, RESLIST_SMAX,
RESLIST_HMAX, RESLIST_TTL);
rv = apr_reslist_create(&rl, RESLIST_MIN, RESLIST_SMAX, RESLIST_HMAX,
RESLIST_TTL, my_constructor, my_destructor,
params, pool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Error allocating shared memory block\n");
return rv;
}
fprintf(stdout, "OK\n");
printf("Creating %d threads", CONSUMER_THREADS);
for (i = 0; i < CONSUMER_THREADS; i++) {
putchar('.');
my_thread_info[i].tid = i;
my_thread_info[i].reslist = rl;
my_thread_info[i].work_delay_sleep = WORK_DELAY_SLEEP_TIME;
rv = apr_thread_create(&my_threads[i], NULL,
resource_consuming_thread, &my_thread_info[i],
pool);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Failed to create thread %d\n", i);
return rv;
}
}
printf("\nDone!\n");
printf("Waiting for threads to finish");
for (i = 0; i < CONSUMER_THREADS; i++) {
apr_status_t thread_rv;
putchar('.');
apr_thread_join(&thread_rv, my_threads[i]);
if (rv != APR_SUCCESS) {
fprintf(stderr, "Failed to join thread %d\n", i);
return rv;
}
}
printf("\nDone!\n");
printf("Destroying resource list.................");
rv = apr_reslist_destroy(rl);
if (rv != APR_SUCCESS) {
printf("FAILED\n");
return rv;
}
printf("OK\n");
apr_pool_destroy(pool);
return APR_SUCCESS;
}
