void free_event_loop(event_loop_t *event_loop)
{
h2o_multithread_unregister_receiver(event_loop->h2o_ctx.queue, &event_loop->h2o_receiver);
h2o_socket_close(event_loop->h2o_socket);
h2o_socket_close(event_loop->epoll_socket);
h2o_context_dispose(&event_loop->h2o_ctx);
}
void test_lib__common__multithread_c(void)
{
pthread_t tid;
main_thread.loop = create_loop();
main_thread.queue = h2o_multithread_create_queue(main_thread.loop);
h2o_multithread_register_receiver(main_thread.queue, &main_thread.pong_receiver, on_pong);
h2o_multithread_register_receiver(main_thread.queue, &main_thread.shutdown_receiver, on_shutdown);
worker_thread.loop = create_loop();
worker_thread.queue = h2o_multithread_create_queue(worker_thread.loop);
h2o_multithread_register_receiver(worker_thread.queue, &worker_thread.ping_receiver, on_ping);
pthread_create(&tid, NULL, worker_main, NULL);
/* send first message */
send_empty_message(&worker_thread.ping_receiver);
while (!main_thread.received_shutdown) {
#if H2O_USE_LIBUV
uv_run(main_thread.loop, UV_RUN_ONCE);
#else
h2o_evloop_run(main_thread.loop, INT32_MAX);
#endif
}
pthread_join(tid, NULL);
h2o_multithread_unregister_receiver(worker_thread.queue, &worker_thread.ping_receiver);
h2o_multithread_destroy_queue(worker_thread.queue);
destroy_loop(worker_thread.loop);
h2o_multithread_unregister_receiver(main_thread.queue, &main_thread.pong_receiver);
h2o_multithread_unregister_receiver(main_thread.queue, &main_thread.shutdown_receiver);
h2o_multithread_destroy_queue(main_thread.queue);
destroy_loop(main_thread.loop);
ok(1);
}
void free_event_loop(event_loop_t *event_loop, h2o_multithread_receiver_t *h2o_receiver)
{
if (event_loop->h2o_https_socket)
h2o_socket_close(event_loop->h2o_https_socket);
if (event_loop->h2o_socket)
h2o_socket_close(event_loop->h2o_socket);
h2o_multithread_unregister_receiver(event_loop->h2o_ctx.queue, h2o_receiver);
h2o_loop_t * const loop = event_loop->h2o_ctx.loop;
h2o_context_dispose(&event_loop->h2o_ctx);
h2o_evloop_destroy(loop);
}
void h2o_context_dispose(h2o_context_t *ctx)
{
h2o_globalconf_t *config = ctx->globalconf;
size_t i, j;
for (i = 0; config->hosts[i] != NULL; ++i) {
h2o_hostconf_t *hostconf = config->hosts[i];
for (j = 0; j != hostconf->paths.size; ++j) {
h2o_pathconf_t *pathconf = hostconf->paths.entries + j;
h2o_context_dispose_pathconf_context(ctx, pathconf);
}
h2o_context_dispose_pathconf_context(ctx, &hostconf->fallback_path);
}
free(ctx->_pathconfs_inited.entries);
free(ctx->_module_configs);
h2o_timeout_dispose(ctx->loop, &ctx->zero_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->one_sec_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->hundred_ms_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->handshake_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->http1.req_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->http2.idle_timeout);
h2o_timeout_dispose(ctx->loop, &ctx->proxy.io_timeout);
/* what should we do here? assert(!h2o_linklist_is_empty(&ctx->http2._conns); */
h2o_filecache_destroy(ctx->filecache);
ctx->filecache = NULL;
/* TODO assert that the all the getaddrinfo threads are idle */
h2o_multithread_unregister_receiver(ctx->queue, &ctx->receivers.hostinfo_getaddr);
h2o_multithread_destroy_queue(ctx->queue);
#if H2O_USE_LIBUV
/* make sure the handles released by h2o_timeout_dispose get freed */
uv_run(ctx->loop, UV_RUN_NOWAIT);
#endif
}
