int main(int argc, char *argv[])
{
ACL_VSTREAM *sstream, *client;
const char *addr = "127.0.0.1:30082";
acl_init();
sstream = acl_vstream_listen(addr, 128);
if (sstream == NULL) {
printf("listen on %s error(%s)\r\n", addr, acl_last_serror());
getchar();
return (0);
}
printf("listening on %s ...\r\n", addr);
while (1) {
client = acl_vstream_accept(sstream, NULL, 0);
if (client == NULL) {
printf("accept error(%s)\r\n", acl_last_serror());
break;
}
echo(client);
acl_vstream_close(client);
}
printf("Over now\r\n");
getchar();
return (0);
}
static int vstream_server(void)
{
const char *myname = "vstream_server";
ACL_VSTREAM *sstream, *client;
char ebuf[256];
sstream = acl_vstream_listen(addr, 128);
if (sstream == NULL) {
printf("%s(%d): listen on %s error(%s)\r\n",
myname, __LINE__, addr,
acl_last_strerror(ebuf, sizeof(ebuf)));
return (-1);
}
acl_tcp_defer_accept(ACL_VSTREAM_SOCK(sstream), 0);
printf("%s: listen %s ok\r\n", myname, addr);
while (1) {
client = acl_vstream_accept(sstream, NULL, 0);
if (client == NULL) {
printf("%s(%d): accept error(%s)\r\n",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
return (-1);
}
printf("accept one\r\n");
if (1)
reply_client2(client);
else
reply_client(client);
acl_vstream_close(client);
}
return (0);
}
bool master_proc::run_alone(const char* addrs, const char* path /* = NULL */,
int count /* = 1 */)
{
// 每个进程只能有一个实例在运行
acl_assert(has_called == false);
has_called = true;
daemon_mode_ = false;
__count_limit = count;
acl_assert(addrs && *addrs);
#ifdef ACL_WINDOWS
acl_cpp_init();
#endif
ACL_EVENT* eventp = acl_event_new_select(1, 0);
set_event(eventp); // 调用基类方法设置事件引擎句柄
std::vector<ACL_VSTREAM*> sstreams;
ACL_ARGV* tokens = acl_argv_split(addrs, ";,| \t");
ACL_ITER iter;
acl_foreach(iter, tokens)
{
const char* addr = (const char*) iter.data;
ACL_VSTREAM* sstream = acl_vstream_listen(addr, 128);
if (sstream == NULL)
{
logger_error("listen %s error %s",
addr, last_serror());
close_all_listener(sstreams);
acl_argv_free(tokens);
return false;
}
service_on_listen(sstream);
acl_event_enable_listen(eventp, sstream, 0,
listen_callback, sstream);
sstreams.push_back(sstream);
}
acl_argv_free(tokens);
// 初始化配置参数
conf_.load(path);
service_pre_jail(NULL, NULL);
service_init(NULL, NULL);
while (!__stop)
acl_event_loop(eventp);
close_all_listener(sstreams);
acl_event_free(eventp);
service_exit(NULL, NULL);
return true;
}
bool aio_listen_stream::open(const char* addr)
{
ACL_VSTREAM *sstream = acl_vstream_listen(addr, 128);
if (sstream == NULL)
return false;
snprintf(addr_, sizeof(addr_), "%s", ACL_VSTREAM_LOCAL(sstream));
stream_ = acl_aio_open(handle_->get_handle(), sstream);
// 调用基类的 hook_error 以向 handle 中增加异步流计数,
// 同时 hook 关闭及超时回调过程
hook_error();
// hook 监听的回调过程
hook_accept();
return true;
}
static void run_server(const char *addr)
{
ACL_VSTREAM *sstream = acl_vstream_listen(addr, 128);
acl_pthread_pool_t *pool;
CONN *conn;
acl_pthread_t tid;
acl_pthread_attr_t attr;
ACL_VSTREAM *client;
if (sstream == NULL) {
acl_msg_error("listen %s error(%s)", addr, acl_last_serror());
return;
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
printf("listening on %s ...\n", addr);
pool = acl_thread_pool_create(10, 10);
while (1) {
acl_mem_slice_delay_destroy();
if (acl_read_wait(ACL_VSTREAM_SOCK(sstream), 5) == -1)
continue;
client = acl_vstream_accept(sstream, NULL, 0);
if (client == NULL) {
acl_msg_error("accept error(%s)", acl_last_serror());
break;
}
acl_tcp_set_nodelay(ACL_VSTREAM_SOCK(client));
conn = acl_mycalloc(1, sizeof(CONN));
conn->stream = client;
if (0)
thread_run(conn);
else if (1)
acl_pthread_create(&tid, &attr, thread_main, conn);
else
acl_pthread_pool_add(pool, thread_run, conn);
}
acl_vstream_close(sstream);
}
int main(void)
{
const char *addr = "0.0.0.0:8089";
ACL_VSTREAM *sstream = acl_vstream_listen(addr, 128);
fiber_init();
if (sstream == NULL) {
printf("acl_vstream_listen error %s\r\n", acl_last_serror());
return 1;
}
acl_non_blocking(ACL_VSTREAM_SOCK(sstream), ACL_NON_BLOCKING);
printf("%s: call fiber_creater\r\n", __FUNCTION__);
fiber_create(fiber_accept, sstream, 32768);
printf("call fiber_schedule\r\n");
fiber_schedule();
return 0;
}
static void service_test(void)
{
const char *addr = "127.0.0.1:8885";
ACL_VSTREAM *sstream = acl_vstream_listen(addr, 32), *client;
int ret;
assert(sstream != NULL);
acl_xinetd_params_int_table(NULL, var_conf_int_tab);
acl_xinetd_params_str_table(NULL, var_conf_str_tab);
acl_xinetd_params_bool_table(NULL, var_conf_bool_tab);
printf("listen %s ok\n", addr);
service_init(NULL);
while (1) {
client = acl_vstream_accept(sstream, NULL, 0);
if (client == NULL) {
printf("accept error: %s\n", acl_last_serror());
break;
}
while (1) {
if (acl_readable(ACL_VSTREAM_SOCK(client)) == 0)
continue;
ret = service_main(client, NULL);
if (ret < 0) {
acl_vstream_close(client);
break;
}
if (ret > 0)
break;
}
}
service_exit(NULL);
acl_vstream_close(sstream);
}
static void event_dog_open(EVENT_DOG *evdog)
{
const char *myname = "event_dog_open";
const char *addr = "127.0.0.1:0";
char ebuf[256];
evdog->sstream = acl_vstream_listen(addr, 32);
if (evdog->sstream == NULL)
acl_msg_fatal("%s(%d): listen on addr(%s) error(%s)",
myname, __LINE__, addr,
acl_last_strerror(ebuf, sizeof(ebuf)));
evdog->server = acl_vstream_connect(evdog->sstream->local_addr,
ACL_BLOCKING, 0, 0, 1024);
if (evdog->server == NULL)
acl_msg_fatal("%s(%d): connect to addr(%s) error(%s)",
myname, __LINE__, addr,
acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_writen(evdog->server, ebuf, 1) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): pre write error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
evdog->client = acl_vstream_accept(evdog->sstream, ebuf, sizeof(ebuf));
if (evdog->client == NULL)
acl_msg_fatal("%s(%d): accept error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
if (acl_vstream_readn(evdog->client, ebuf, 1) == ACL_VSTREAM_EOF)
acl_msg_fatal("%s(%d): pre read error(%s)",
myname, __LINE__,
acl_last_strerror(ebuf, sizeof(ebuf)));
acl_vstream_close(evdog->sstream);
evdog->sstream = NULL;
acl_event_enable_read(evdog->eventp, evdog->client, 0, read_fn, evdog);
}
int main(int argc, char *argv[])
{
ACL_VSTREAM *sstream, *client;
ACL_WORK_QUEUE* wq = acl_workq_create(100, 60, NULL, NULL);
char ch, *addr = "127.0.0.1:8889";
char *regnum = "regnum";
while ((ch = getopt(argc, argv, "hs:f:")) > 0) {
switch (ch) {
default:
case 'h':
usage(argv[0]);
exit (0);
case 's':
addr = acl_mystrdup(optarg);
break;
case 'f':
regnum = optarg;
break;
}
}
var_cfg_cache_file = acl_mystrdup(regnum);
acl_socket_init();
service_init(NULL);
sstream = acl_vstream_listen(addr, 32);
if (sstream == NULL)
acl_msg_fatal("can't listen on addr(%s)", addr);
printf("started, listen on %s ...\r\n", addr);
while (1) {
client = acl_vstream_accept(sstream, NULL, 0);
acl_workq_add(wq, client_thread, 0, client);
}
exit (0);
}
bool master_threads::run_alone(const char* addrs, const char* path /* = NULL */,
unsigned int count /* = 1 */, int threads_count /* = 1 */)
{
// 每个进程只能有一个实例在运行
acl_assert(has_called == false);
has_called = true;
daemon_mode_ = false;
acl_assert(addrs && *addrs);
__count_limit = count;
#ifdef WIN32
acl_init();
#endif
std::vector<ACL_VSTREAM*> sstreams;
ACL_EVENT* eventp = acl_event_new_select_thr(1, 0);
set_event(eventp); // 设置基类的事件句柄
ACL_ARGV* tokens = acl_argv_split(addrs, ";,| \t");
ACL_ITER iter;
acl_foreach(iter, tokens)
{
const char* addr = (const char*) iter.data;
ACL_VSTREAM* sstream = acl_vstream_listen(addr, 128);
if (sstream == NULL)
{
logger_error("listen %s error(%s)",
addr, acl_last_serror());
acl_argv_free(tokens);
close_sstreams(eventp, sstreams);
acl_event_free(eventp);
return false;
}
acl_event_enable_listen(eventp, sstream, 0,
listen_callback, sstream);
sstreams.push_back(sstream);
}
acl_argv_free(tokens);
// 初始化配置参数
conf_.load(path);
service_pre_jail(NULL);
service_init(NULL);
if (threads_count > 1)
{
__thread_pool = acl_thread_pool_create(threads_count, 120);
acl_pthread_pool_atinit(__thread_pool, thread_begin, NULL);
acl_pthread_pool_atfree(__thread_pool, thread_finish, NULL);
}
else
thread_init(NULL);
while (!__stop)
acl_event_loop(eventp);
if (__thread_pool)
acl_pthread_pool_destroy(__thread_pool);
else
thread_exit(NULL);
service_exit(NULL);
// 必须在调用 acl_event_free 前调用 close_sstreams，因为在关闭
// 网络流对象时依然有对 ACL_EVENT 引擎的使用
close_sstreams(eventp, sstreams);
acl_event_free(eventp);
eventp = NULL;
return true;
}
