int swTask_start(swTask *task)
{
int ret;
ret = swReactorSelect_create(&task->reactor);
if(ret < 0)
{
swTrace("create reactor fail\n");
return ret;
}
if(task->factory_mode == SW_MODE_PROCESS)
{
ret = swFactoryProcess_create(&task->factory, task->writer_num, task->worker_num);
}
//default mode SW_MODE_THREAD
else
{
ret = swFactoryThread_create(&task->factory, task->writer_num);
}
if(ret < 0)
{
swTrace("create factory fail\n");
return ret;
}
return SW_OK;
}
/**
* 使用Unix Socket通信
*/
int swFactoryProcess_writer_loop_unsock(swThreadParam *param)
{
swFactory *factory = param->object;
swFactoryProcess *object = factory->object;
int pti = param->pti;
swReactor *reactor = &(object->writers[pti].reactor);
struct timeval tmo;
tmo.tv_sec = 3;
tmo.tv_usec = 0;
reactor->factory = factory;
reactor->id = pti;
if (swReactorSelect_create(reactor) < 0)
{
swWarn("swReactorSelect_create fail\n");
pthread_exit((void *) param);
}
swSingalNone();
reactor->setHandle(reactor, SW_FD_PIPE, swFactoryProcess_writer_receive);
reactor->wait(reactor, &tmo);
reactor->free(reactor);
pthread_exit((void *) param);
return SW_OK;
}
int swReactor_create(swReactor *reactor, int max_event)
{
int ret;
bzero(reactor, sizeof(swReactor));
#ifdef HAVE_EPOLL
ret = swReactorEpoll_create(reactor, max_event);
#elif defined(HAVE_KQUEUE)
ret = swReactorKqueue_create(reactor, max_event);
#elif defined(HAVE_POLL)
ret = swReactorPoll_create(reactor, max_event);
#else
ret = swReactorSelect_create(reactor);
#endif
reactor->running = 1;
reactor->setHandle = swReactor_setHandle;
reactor->onFinish = swReactor_onFinish;
reactor->onTimeout = swReactor_onTimeout;
reactor->write = swReactor_write;
reactor->defer = swReactor_defer;
reactor->close = swReactor_close;
reactor->socket_array = swArray_new(1024, sizeof(swConnection));
if (!reactor->socket_array)
{
swWarn("create socket array failed.");
return SW_ERR;
}
return ret;
}
int swReactor_create(swReactor *reactor, int max_event)
{
int ret;
bzero(reactor, sizeof(swReactor));
//event less than SW_REACTOR_MINEVENTS, use poll/select
if (max_event <= SW_REACTOR_MINEVENTS)
{
#ifdef SW_MAINREACTOR_USE_POLL
ret = swReactorPoll_create(reactor, SW_REACTOR_MINEVENTS);
#else
ret = swReactorSelect_create(reactor);
#endif
}
//use epoll or kqueue
else
{
#ifdef HAVE_EPOLL
ret = swReactorEpoll_create(reactor, max_event);
#elif defined(HAVE_KQUEUE)
ret = swReactorKqueue_create(reactor, max_event);
#elif defined(SW_MAINREACTOR_USE_POLL)
ret = swReactorPoll_create(reactor, max_event);
#else
ret = swReactorSelect_create(reactor);
#endif
}
reactor->running = 1;
reactor->setHandle = swReactor_setHandle;
reactor->onFinish = swReactor_onFinish;
reactor->onTimeout = swReactor_onTimeout;
reactor->write = swReactor_write;
reactor->close = swReactor_close;
reactor->socket_array = swArray_new(1024, sizeof(swConnection), 0);
if (!reactor->socket_array)
{
swWarn("create socket array failed.");
return SW_ERR;
}
return ret;
}
/**
* proxy模式
* 在单独的n个线程中接受维持TCP连接
*/
static int swServer_start_proxy(swServer *serv)
{
int ret;
swReactor *main_reactor = SwooleG.memory_pool->alloc(SwooleG.memory_pool, sizeof(swReactor));
#ifdef SW_MAINREACTOR_USE_POLL
ret = swReactorPoll_create(main_reactor, 10);
#else
ret = swReactorSelect_create(main_reactor);
#endif
if (ret < 0)
{
swWarn("Swoole reactor create fail");
return SW_ERR;
}
ret = swReactorThread_start(serv, main_reactor);
if (ret < 0)
{
swWarn("Swoole poll thread start fail");
return SW_ERR;
}
SwooleG.main_reactor = main_reactor;
main_reactor->id = serv->reactor_num; //设为一个特别的ID
main_reactor->ptr = serv;
main_reactor->setHandle(main_reactor, SW_FD_LISTEN, swServer_master_onAccept);
main_reactor->setHandle(main_reactor, (SW_FD_USER+2), swServer_master_onClose);
main_reactor->onFinish = swServer_master_onReactorFinish;
main_reactor->onTimeout = swServer_master_onReactorTimeout;
#ifdef HAVE_SIGNALFD
if (SwooleG.use_signalfd)
{
swSignalfd_setup(main_reactor);
}
#endif
main_reactor->add(main_reactor, serv->main_pipe.getFd(&serv->main_pipe, 0), (SW_FD_USER+2));
//no use
//SW_START_SLEEP;
if (serv->onStart != NULL)
{
serv->onStart(serv);
}
struct timeval tmo;
tmo.tv_sec = SW_MAINREACTOR_TIMEO;
tmo.tv_usec = 0;
//先更新一次时间
swServer_update_time();
return main_reactor->wait(main_reactor, &tmo);
}
int swFactoryProcess_writer_loop(swThreadParam *param)
{
swFactory *factory = param->object;
swFactoryProcess *this = factory->object;
int pti = param->pti;
swReactor *reactor = &(this->writers[pti].reactor);
struct timeval tmo;
tmo.tv_sec = 3;
tmo.tv_usec = 0;
reactor->factory = factory;
reactor->id = pti;
if (swReactorSelect_create(reactor) < 0)
{
swTrace("swReactorSelect_create fail\n");
pthread_exit((void *)param);
}
reactor->setHandle(reactor, SW_FD_CONN, swFactoryProcess_writer_receive);
reactor->wait(reactor, &tmo);
reactor->free(reactor);
pthread_exit((void *)param);
return SW_OK;
}
int swServer_start(swServer *serv)
{
swReactor main_reactor;
swFactory *factory = &serv->factory;
struct sockaddr_in serveraddr;
struct timeval tmo;
int ret, step = 0;
int option;
ret = swServer_check_callback(serv);
if (ret < 0)
{
return ret;
}
//run as daemon
if(serv->daemonize > 0 )
{
if(daemon(1, 1) < 0)
{
return SW_ERR;
}
}
ret = factory->start(factory);
if (ret < 0)
{
return ret;
}
ret = swServer_poll_start(serv);
if (ret < 0)
{
return ret;
}
bzero(&serveraddr, sizeof(struct sockaddr_in));
//设置serveraddr
inet_aton(serv->host, &(serveraddr.sin_addr));
serveraddr.sin_port = htons(serv->port);
serveraddr.sin_family = AF_INET;
swTrace("Bind host=%s,port=%d \n", serv->host, serv->port);
//创建监听套接字
serv->sock = socket(PF_INET, SOCK_STREAM, 0);
option = 1;
setsockopt(serv->sock, SOL_SOCKET, SO_REUSEADDR, &option, sizeof(int));
if (serv->sock < 0)
{
swTrace("[swServerCreate]create socket fail\n");
return --step;
}
//将监听套接字同sockaddr绑定
ret = bind(serv->sock, (struct sockaddr *) &serveraddr, sizeof(struct sockaddr_in));
if (ret != 0)
{
swTrace("[swServerCreate]bind fail\n");
return --step;
}
//开始监听套接字
ret = listen(serv->sock, serv->backlog);
if (ret != 0)
{
swTrace("[swServerCreate]listen fail\n");
return --step;
}
ret = swReactorSelect_create(&main_reactor);
if (ret < 0)
{
return SW_ERR;
}
main_reactor.ptr = serv;
main_reactor.setHandle(&main_reactor, SW_EVENT_CLOSE, swServer_onClose);
main_reactor.setHandle(&main_reactor, SW_EVENT_CONNECT, swServer_onAccept);
main_reactor.add(&main_reactor, serv->event_fd, SW_EVENT_CLOSE);
main_reactor.add(&main_reactor, serv->sock, SW_EVENT_CONNECT);
tmo.tv_sec = 5;
tmo.tv_usec = 0;
serv->onStart(serv);
main_reactor.wait(&main_reactor, &tmo);
serv->onShutdown(serv);
return SW_OK;
}
