int main(int argc, char** argv) {
signal(SIGABRT, &sighandler);
signal(SIGTERM, &sighandler);
signal(SIGINT, &sighandler);
initServer();
aeEventLoop* eventLoop = aeCreateEventLoop(server.max_process_client + SHTTPSVR_EVENTLOOP_FDSET_INCR);
server.el = eventLoop;
int listen_socket = anetTcpServer(NULL, 80, NULL, server.tcp_backlog);
anetNonBlock(NULL, listen_socket);
if (listen_socket > 0
&& AE_ERR == aeCreateFileEvent(eventLoop, listen_socket, AE_READABLE, tAcceptProc, NULL)) {
ERRLOG("aeCreateFileEvent error!");
exit(1);
}
aeSetBeforeSleepProc(eventLoop, tBeforeSleepProc);
initTimeEvent(eventLoop);
aeMain(eventLoop);
aeDeleteEventLoop(eventLoop);
return 0;
}
aeServer* aeServerCreate( char* ip,int port )
{
aeServer* serv = (aeServer*)zmalloc( sizeof(aeServer ));
serv->runForever = startServer;
serv->send = sendMessageToReactor;
serv->close = sendCloseEventToReactor;
serv->sendToClient = anetWrite;
serv->closeClient = freeClient;
serv->listen_ip = ip;
serv->port = port;
serv->connectNum = 0;
serv->reactorNum = 2;
serv->workerNum = 3;
serv->maxConnect = 1024;
serv->connlist = shm_calloc( serv->maxConnect , sizeof( aeConnection ));
serv->reactorThreads = zmalloc( serv->reactorNum * sizeof( aeReactorThread ));
serv->workers = zmalloc( serv->workerNum * sizeof(aeWorkerProcess));
serv->mainReactor = zmalloc( sizeof( aeReactor ));
serv->mainReactor->eventLoop = aeCreateEventLoop( 10 );
aeSetBeforeSleepProc( serv->mainReactor->eventLoop ,initOnLoopStart );
//安装信号装置
installMasterSignal( serv );
servG = serv;
return serv;
}
void *reactorThreadRun(void *arg)
{
reactorThreadParam* param = (reactorThreadParam*)arg;
aeServer* serv = param->serv;
int thid = param->thid;
aeEventLoop* el = aeCreateEventLoop( 1024 );
serv->reactorThreads[thid].reactor.eventLoop = el;
int ret,i;
//每个线程都有workerNum个worker pipe
for( i = 0; i < serv->workerNum; i++ )
{
if ( aeCreateFileEvent( el,serv->workers[i].pipefd[0],
AE_READABLE,onMasterPipeReadable, thid ) == -1 )
{
printf( "CreateFileEvent error fd " );
close(serv->workers[i].pipefd[0]);
}
}
aeSetBeforeSleepProc( el ,initThreadOnLoopStart );
aeMain( el );
aeDeleteEventLoop( el );
el = NULL;
}
void *reactorThreadRun( void *arg )
{
reactorThreadParam *param = (reactorThreadParam *) arg;
appnetServer *serv = param->serv;
int thid = param->thid;
aeEventLoop *el = aeCreateEventLoop( MAX_EVENT );
serv->reactor_threads[thid].reactor.event_loop = el;
serv->reactor_threads[thid].hh = (httpHeader *) malloc( sizeof(httpHeader) );
serv->reactor_threads[thid].hs = (handshake *) malloc( sizeof(handshake) );
int ret,i,index;
for (i = 0; i < serv->worker_num + serv->task_worker_num; i++)
{
index = i * serv->reactor_num + thid;
if (aeCreateFileEvent( el , serv->worker_pipes[index].pipefd[0] , AE_READABLE ,
onMasterPipeReadable , thid ) == -1)
{
printf( "CreateFileEvent error fd " );
close( serv->worker_pipes[index].pipefd[0] );
}
}
aeSetBeforeSleepProc( el , initThreadOnLoopStart );
aeMain( el );
aeDeleteEventLoop( el );
free( serv->reactor_threads[thid].hh );
free( serv->reactor_threads[thid].hs );
el = NULL;
}
int main(int argc, char **argv) {
time_t start;
initServerConfig();
if (argc == 2) {
resetServerSaveParams();
loadServerConfig(argv[1]);
}
if (server.daemonize) daemonize();
initServer();
linuxOvercommitMemoryWarning();
start = time(NULL);
if (server.appendonly) {
loadAppendOnlyFile(server.appendfilename);
} else {
rdbLoad(server.dbfilename);
}
aeSetBeforeSleepProc(server.el,beforeSleep);
aeMain(server.el);
aeDeleteEventLoop(server.el);
return 0;
}
int run_storage_service()
{
aeSetBeforeSleepProc(g_storage_service.eventLoop,NULL);
aeMain(g_storage_service.eventLoop);
aeDeleteEventLoop(g_storage_service.eventLoop);
close(g_storage_service.sockfd);
return 0;
}
/* 启动网络
*/
static void* _NTInit(void* _v) {
pthread_mutex_lock(&g_rootThreadMutex);
int listenPort;
struct configOption *confOpt;
char tmpstr[TMPSTR_SIZE] = {""};
confOpt = configGet(g_conf, "net_server", "port");
if (NULL != confOpt) {
if (confOpt->valueLen > TMPSTR_SIZE) {
trvExit(0, "监听端口太大");
}
memcpy(tmpstr, confOpt->value, confOpt->valueLen);
tmpstr[confOpt->valueLen] = 0;
listenPort = atoi(tmpstr);
}
else listenPort = -1; /* 输入一个不正常的监听端口，意味着不监听 */
if (ERRNO_ERR == NTInit(listenPort)) {
trvExit(0, "初始化网络失败");
}
/*
if(aeCreateTimeEvent(g_server.el, 1, serverCron, NULL, NULL) == AE_ERR) {
trvLogE("Can't create the serverCron time event.");
exit(1);
}
*/
aeSetBeforeSleepProc(g_server.el, beforeSleep);
pthread_mutex_unlock(&g_rootThreadMutex);
pthread_cond_signal(&g_rootThreadCond);
aeMain(g_server.el);
aeDeleteEventLoop(g_server.el);
return NULL;
}
void initServer( appnetServer *serv )
{
serv->connlist = shm_calloc( serv->connect_max , sizeof(appnetConnection) );
serv->reactor_threads =
zmalloc( serv->reactor_num * sizeof(appnetReactorThread) );
serv->workers = zmalloc( ( serv->worker_num + serv->task_worker_num ) *
sizeof(appnetWorkerProcess) );
serv->worker_pipes = zmalloc( ( serv->worker_num + serv->task_worker_num ) *
serv->reactor_num * sizeof(appnetWorkerPipes) );
srand( (unsigned) time( NULL ) );
serv->main_reactor = zmalloc( sizeof(appnetReactor) );
serv->main_reactor->event_loop = aeCreateEventLoop( 10 );
aeSetBeforeSleepProc( serv->main_reactor->event_loop , initOnLoopStart );
installMasterSignal( serv );
}
/* Main */
int
clusterMain (int argc, char **argv)
{
long long teid;
redisLog (REDIS_WARNING, "Server started, Redis version " REDIS_VERSION);
#ifdef __linux__
linuxOvercommitMemoryWarning ();
#endif
loadDataFromDisk ();
server.last_bgsave_seqnum = server.smr_seqnum;
/* Warning the user about suspicious maxmemory setting. */
if (server.maxmemory > 0 && server.maxmemory < 1024 * 1024)
{
redisLog (REDIS_WARNING,
"WARNING: You specified a maxmemory value that is less than 1MB (current value is %llu bytes). Are you sure this is what you really want?",
server.maxmemory);
}
smrConnect ();
/* initializeCron for handling sigterm */
teid = aeCreateTimeEvent (server.el, 1, initializeCron, NULL, NULL);
aeMain (server.el);
aeDeleteTimeEvent (server.el, teid);
if (server.need_rckpt)
{
redisLog (REDIS_NOTICE,
"Need more checkpoint from %s:%d", server.ckpt_host,
server.ckpt_port);
smrDisconnect ();
server.smr_init_flags = SMR_INIT_RCKPT;
if (getdump
(server.ckpt_host, server.ckpt_port, server.rdb_filename,
"0-8191", REDIS_GETDUMP_DEFAULT_NET_LIMIT_MB) != REDIS_OK)
{
exit (1);
}
emptyDb (NULL);
loadDataFromDisk ();
server.last_bgsave_seqnum = server.smr_seqnum;
smrConnect ();
aeMain (server.el);
}
if (!server.is_ready)
{
redisLog (REDIS_WARNING, "Invalid initialization state");
exit (1);
}
if (server.last_bgsave_seqnum)
{
if (smr_seq_ckpted (server.smr_conn, server.last_bgsave_seqnum) != 0)
{
redisLog (REDIS_WARNING,
"Failed to notify checkpointed sequence to smr");
exit (1);
}
else
{
redisLog (REDIS_NOTICE,
"Checkpointed sequence is sent to SMR, seqnum:%lld",
server.last_bgsave_seqnum);
}
}
server.smr_seqnum_reset = 0;
server.last_catchup_check_mstime = mstime ();
server.smr_init_flags = SMR_INIT_CATCHUP_PHASE1;
if (smr_catchup (server.smr_conn) == -1)
{
redisLog (REDIS_WARNING, "Failed to catchup errno(%d)", errno);
exit (1);
}
server.smr_init_flags = SMR_INIT_CATCHUP_PHASE2;
checkSmrCatchup ();
aeSetBeforeSleepProc (server.el, beforeSleep);
aeMain (server.el);
aeDeleteEventLoop (server.el);
exit (0);
}
