/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_aiop_ref_t tb_aiop_init(tb_size_t maxn)
{
// check
tb_assert_and_check_return_val(maxn, tb_null);
// done
tb_bool_t ok = tb_false;
tb_aiop_impl_t* impl = tb_null;
do
{
// make impl
impl = tb_malloc0_type(tb_aiop_impl_t);
tb_assert_and_check_break(impl);
// init impl
impl->maxn = maxn;
// init lock
if (!tb_spinlock_init(&impl->lock)) break;
// init pool
impl->pool = tb_fixed_pool_init(tb_null, (maxn >> 4) + 16, sizeof(tb_aioo_impl_t), tb_null, tb_null, tb_null);
tb_assert_and_check_break(impl->pool);
// init spak
if (!tb_socket_pair(TB_SOCKET_TYPE_TCP, impl->spak)) break;
// init reactor
impl->rtor = tb_aiop_rtor_impl_init(impl);
tb_assert_and_check_break(impl->rtor);
// addo spak
if (!tb_aiop_addo((tb_aiop_ref_t)impl, impl->spak[1], TB_AIOE_CODE_RECV, tb_null)) break;
// register lock profiler
#ifdef TB_LOCK_PROFILER_ENABLE
tb_lock_profiler_register(tb_lock_profiler(), (tb_pointer_t)&impl->lock, TB_TRACE_MODULE_NAME);
#endif
// ok
ok = tb_true;
} while (0);
// failed?
if (!ok)
{
// exit it
if (impl) tb_aiop_exit((tb_aiop_ref_t)impl);
impl = tb_null;
}
// ok?
return (tb_aiop_ref_t)impl;
}
tb_void_t tb_aiop_cler(tb_aiop_ref_t aiop)
{
// check
tb_aiop_impl_t* impl = (tb_aiop_impl_t*)aiop;
tb_assert_and_check_return(impl);
// clear reactor
if (impl->rtor && impl->rtor->cler)
impl->rtor->cler(impl->rtor);
// clear pool
tb_spinlock_enter(&impl->lock);
if (impl->pool) tb_fixed_pool_clear(impl->pool);
tb_spinlock_leave(&impl->lock);
// addo spak
if (impl->spak[1]) tb_aiop_addo(aiop, impl->spak[1], TB_AIOE_CODE_RECV, tb_null);
}
/* //////////////////////////////////////////////////////////////////////////////////////
* main
*/
tb_int_t tb_demo_asio_aiopd_main(tb_int_t argc, tb_char_t** argv)
{
// check
tb_assert_and_check_return_val(argv[1], 0);
// done
tb_socket_ref_t sock = tb_null;
tb_aiop_ref_t aiop = tb_null;
do
{
// init sock
sock = tb_socket_init(TB_SOCKET_TYPE_TCP);
tb_assert_and_check_break(sock);
// init aiop
aiop = tb_aiop_init(16);
tb_assert_and_check_break(aiop);
// bind
if (!tb_socket_bind(sock, tb_null, 9090)) break;
// listen sock
if (!tb_socket_listen(sock, 20)) break;
// addo sock
if (!tb_aiop_addo(aiop, sock, TB_AIOE_CODE_ACPT, tb_null)) break;
// accept
tb_aioe_t list[16];
while (1)
{
// wait
tb_long_t objn = tb_aiop_wait(aiop, list, 16, -1);
tb_assert_and_check_break(objn >= 0);
// walk list
tb_size_t i = 0;
for (i = 0; i < objn; i++)
{
// the aioo
tb_aioo_ref_t aioo = list[i].aioo;
// check
tb_assert_and_check_break(aioo && tb_aioo_sock(aioo));
// acpt?
if (list[i].code & TB_AIOE_CODE_ACPT)
{
// done acpt
tb_bool_t ok = tb_false;
tb_demo_context_t* context = tb_null;
do
{
// make context
context = tb_malloc0_type(tb_demo_context_t);
tb_assert_and_check_break(context);
// init sock
context->sock = tb_socket_accept(tb_aioo_sock(aioo), tb_null, tb_null);
tb_assert_and_check_break(context->sock);
// init file
context->file = tb_file_init(argv[1], TB_FILE_MODE_RO);
tb_assert_and_check_break(context->file);
// init data
context->data = tb_malloc_bytes(TB_DEMO_FILE_READ_MAXN);
tb_assert_and_check_break(context->data);
// addo sock
context->aioo = tb_aiop_addo(aiop, context->sock, TB_AIOE_CODE_SEND, context);
tb_assert_and_check_break(context->aioo);
// trace
tb_trace_i("acpt[%p]: ok", context->sock);
// init left
context->left = tb_file_size(context->file);
// done read
tb_long_t real = tb_file_read(context->file, context->data, tb_min((tb_size_t)context->left, TB_DEMO_FILE_READ_MAXN));
tb_assert_and_check_break(real > 0);
// save size
context->left -= real;
// trace
// tb_trace_i("read[%p]: real: %ld", context->file, real);
// done send
context->send = real;
real = tb_socket_send(context->sock, context->data + context->real, context->send - context->real);
if (real >= 0)
{
// save real
context->real += real;
// trace
// tb_trace_i("send[%p]: real: %ld", context->sock, real);
}
else
{
// trace
tb_trace_i("send[%p]: closed", context->sock);
break;
}
// ok
ok = tb_true;
} while (0);
// failed or closed?
if (!ok)
{
// exit context
tb_demo_context_exit(aiop, context);
break;
}
}
// writ?
else if (list[i].code & TB_AIOE_CODE_SEND)
{
// the context
tb_demo_context_t* context = (tb_demo_context_t*)list[i].priv;
tb_assert_and_check_break(context);
// continue to send it if not finished
if (context->real < context->send)
{
// done send
tb_long_t real = tb_socket_send(tb_aioo_sock(aioo), context->data + context->real, context->send - context->real);
if (real > 0)
{
// save real
context->real += real;
// trace
// tb_trace_i("send[%p]: real: %ld", tb_aioo_sock(aioo), real);
}
else
{
// trace
tb_trace_i("send[%p]: closed", tb_aioo_sock(aioo));
// exit context
tb_demo_context_exit(aiop, context);
break;
}
}
// finished? read file
else if (context->left)
{
// init
context->real = 0;
context->send = 0;
// done read
tb_size_t tryn = 1;
tb_long_t real = 0;
while (!(real = tb_file_read(context->file, context->data, tb_min((tb_size_t)context->left, TB_DEMO_FILE_READ_MAXN))) && tryn--);
if (real > 0)
{
// save left
context->left -= real;
// trace
// tb_trace_i("read[%p]: real: %ld", context->file, real);
// done send
context->send = real;
real = tb_socket_send(tb_aioo_sock(aioo), context->data, context->send);
if (real >= 0)
{
// save real
context->real += real;
// trace
// tb_trace_i("send[%p]: real: %ld", tb_aioo_sock(aioo), real);
}
else
{
// trace
tb_trace_i("send[%p]: closed", tb_aioo_sock(aioo));
// exit context
tb_demo_context_exit(aiop, context);
break;
}
}
else
{
// trace
tb_trace_i("read[%p]: closed", tb_aioo_sock(aioo));
// exit context
tb_demo_context_exit(aiop, context);
break;
}
}
else
{
// trace
tb_trace_i("read[%p]: closed", tb_aioo_sock(aioo));
// exit context
tb_demo_context_exit(aiop, context);
break;
}
}
// error?
else
{
tb_trace_i("aioe[%p]: unknown code: %lu", tb_aioo_sock(aioo), list[i].code);
break;
}
}
}
} while (0);
// trace
tb_trace_i("end");
// exit socket
if (sock) tb_socket_exit(sock);
// exit aiop
if (aiop) tb_aiop_exit(aiop);
// end
return 0;
}
static tb_bool_t tb_aiop_spak_wait(tb_aiop_ptor_impl_t* impl, tb_aice_ref_t aice)
{
// check
tb_assert_and_check_return_val(impl && impl->aiop && impl->ltimer && aice, tb_false);
// the aico
tb_aiop_aico_t* aico = (tb_aiop_aico_t*)aice->aico;
tb_assert_and_check_return_val(aico && aico->base.handle && !aico->task, tb_false);
// the aioe code
tb_size_t code = tb_aiop_aioe_code(aice);
tb_assert_and_check_return_val(code != TB_AIOE_CODE_NONE, tb_false);
// trace
tb_trace_d("wait: aico: %p, code: %lu: time: %lld: ..", aico, aice->code, tb_cache_time_mclock());
// done
tb_bool_t ok = tb_false;
tb_aice_t prev = aico->aice;
do
{
// wait it
aico->aice = *aice;
aico->waiting = 1;
aico->wait_ok = 0;
// wait once if not accept
if (aice->code != TB_AICE_CODE_ACPT) code |= TB_AIOE_CODE_ONESHOT;
// using the edge triggered mode
if (tb_aiop_have(impl->aiop, TB_AIOE_CODE_CLEAR))
code |= TB_AIOE_CODE_CLEAR;
// have aioo?
if (!aico->aioo)
{
// addo wait
if (!(aico->aioo = tb_aiop_addo(impl->aiop, aico->base.handle, code, &aico->aice))) break;
}
else
{
// sete wait
if (!tb_aiop_sete(impl->aiop, aico->aioo, code, &aico->aice)) break;
}
// add timeout task
tb_long_t timeout = tb_aico_impl_timeout_from_code((tb_aico_impl_t*)aico, aice->code);
if (timeout >= 0)
{
// add it
aico->task = tb_ltimer_task_init(impl->ltimer, timeout, tb_false, tb_aiop_spak_wait_timeout, aico);
tb_assert_and_check_break(aico->task);
aico->bltimer = 1;
}
// ok
ok = tb_true;
} while (0);
// failed? restore it
if (!ok)
{
// trace
tb_trace_d("wait: aico: %p, code: %lu: failed", aico, aice->code);
// restore it
aico->aice = prev;
aico->waiting = 0;
}
// ok?
return ok;
}
