int swProcessPool_run(swProcessPool *ma)
{
int i;
for (i = 0; i < ma->worker_num; i++)
{
swProcessPool_spawn(ma, &(ma->workers[i]));
}
return swProcessPool_main_loop(ma);
}
/**
* start
*/
int swProcessPool_start(swProcessPool *pool)
{
int i;
for (i = 0; i < pool->worker_num; i++)
{
if(swProcessPool_spawn(&(pool->workers[i])) < 0)
{
swWarn("swProcessPool_spawn fail");
return SW_ERR;
}
}
return SW_OK;
}
/**
* start workers
*/
int swProcessPool_start(swProcessPool *pool)
{
int i;
for (i = 0; i < pool->worker_num; i++)
{
pool->workers[i].pool = pool;
pool->workers[i].id = pool->start_id + i;
pool->workers[i].type = pool->type;
if (swProcessPool_spawn(&(pool->workers[i])) < 0)
{
return SW_ERR;
}
}
return SW_OK;
}
int swProcessPool_wait(swProcessPool *pool)
{
int pid, new_pid;
int reload_worker_i = 0;
int ret;
int status;
swWorker *reload_workers;
reload_workers = sw_calloc(pool->worker_num, sizeof(swWorker));
if (reload_workers == NULL)
{
swError("[manager] malloc[reload_workers] fail.\n");
return SW_ERR;
}
while (SwooleG.running)
{
pid = wait(&status);
if (pid < 0)
{
if (pool->reloading == 0)
{
swTrace("[Manager] wait failed. Error: %s [%d]", strerror(errno), errno);
}
else if (pool->reload_flag == 0)
{
swTrace("[Manager] reload workers.");
memcpy(reload_workers, pool->workers, sizeof(swWorker) * pool->worker_num);
pool->reload_flag = 1;
goto reload_worker;
}
else if (SwooleG.running == 0)
{
break;
}
}
swTrace("[Manager] worker stop.pid=%d", pid);
if (SwooleG.running == 1)
{
swWorker *exit_worker = swHashMap_find_int(pool->map, pid);
if (exit_worker == NULL)
{
if (pool->onWorkerNotFound)
{
pool->onWorkerNotFound(pool, pid, status);
}
else
{
swWarn("[Manager]unknow worker[pid=%d]", pid);
}
continue;
}
if (!WIFEXITED(status))
{
swWarn("worker#%d abnormal exit, status=%d, signal=%d", exit_worker->id, WEXITSTATUS(status), WTERMSIG(status));
}
new_pid = swProcessPool_spawn(exit_worker);
if (new_pid < 0)
{
swWarn("Fork worker process failed. Error: %s [%d]", strerror(errno), errno);
sw_free(reload_workers);
return SW_ERR;
}
swHashMap_del_int(pool->map, pid);
}
//reload worker
reload_worker:
if (pool->reloading == 1)
{
//reload finish
if (reload_worker_i >= pool->worker_num)
{
pool->reloading = 0;
reload_worker_i = 0;
continue;
}
ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);
if (ret < 0)
{
swSysError("[Manager]kill(%d) failed.", reload_workers[reload_worker_i].pid);
continue;
}
reload_worker_i++;
}
}
sw_free(reload_workers);
return SW_OK;
}
int swProcessPool_wait(swProcessPool *pool)
{
int pid, new_pid;
int reload_worker_i = 0;
int ret, i;
swWorker *reload_workers;
reload_workers = sw_calloc(pool->worker_num, sizeof(swWorker));
if (reload_workers == NULL)
{
swError("[manager] malloc[reload_workers] fail.\n");
return SW_ERR;
}
while (1)
{
pid = wait(NULL);
swTrace("[manager] worker stop.pid=%d\n", pid);
if (pid < 0)
{
if (pool->reloading == 0)
{
swTrace("[Manager] wait fail. Error: %s [%d]", strerror(errno), errno);
}
else if (pool->reload_flag == 0)
{
memcpy(reload_workers, pool->workers, sizeof(swWorker) * pool->worker_num);
pool->reload_flag = 1;
goto reload_worker;
}
}
if (SwooleG.running == 1)
{
swWorker *exit_worker = swHashMap_find_int(&pool->map, pid);
if (exit_worker == NULL)
{
swWarn("[Manager]unknow worker[pid=%d]", pid);
continue;
}
new_pid = swProcessPool_spawn(exit_worker);
if (new_pid < 0)
{
swWarn("Fork worker process fail. Error: %s [%d]", strerror(errno), errno);
return SW_ERR;
}
swHashMap_del_int(&pool->map, pid);
}
//reload worker
reload_worker: if (pool->reloading == 1)
{
//reload finish
if (reload_worker_i >= pool->worker_num)
{
pool->reloading = 0;
reload_worker_i = 0;
continue;
}
ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);
if (ret < 0)
{
swWarn("[Manager]kill fail.pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid,
strerror(errno), errno);
continue;
}
reload_worker_i++;
}
}
return SW_OK;
}
static int swFactoryProcess_manager_loop(swFactory *factory)
{
int pid, new_pid;
int i, writer_pti;
int reload_worker_i = 0;
int ret;
swFactoryProcess *object = factory->object;
swServer *serv = factory->ptr;
swWorker *reload_workers;
reload_workers = sw_calloc(object->worker_num, sizeof(swWorker));
if (reload_workers == NULL)
{
swError("[manager] malloc[reload_workers] fail.\n");
return SW_ERR;
}
//for reload
swSignalSet(SIGUSR1, swManagerSignalHanlde, 1, 0);
while (swoole_running > 0)
{
pid = wait(NULL);
swTrace("[manager] worker stop.pid=%d\n", pid);
if (pid < 0)
{
if (manager_worker_reloading == 0)
{
swTrace("[Manager] wait fail. Error: %s [%d]", strerror(errno), errno);
}
else if (manager_reload_flag == 0)
{
memcpy(reload_workers, object->workers, sizeof(swWorker) * object->worker_num);
manager_reload_flag = 1;
goto kill_worker;
}
}
if (swoole_running == 1)
{
for (i = 0; i < object->worker_num; i++)
{
//对比pid
if (pid != object->workers[i].pid)
{
continue;
}
else
{
pid = 0;
new_pid = swFactoryProcess_worker_spawn(factory, i);
if (new_pid < 0)
{
swWarn("Fork worker process fail. Error: %s [%d]", strerror(errno), errno);
return SW_ERR;
}
else
{
object->workers[i].pid = new_pid;
}
}
}
//task worker
if(pid > 0)
{
swWorker *exit_worker = swHashMap_find_int(&SwooleG.task_workers.map, pid);
if (exit_worker != NULL)
{
swProcessPool_spawn(&SwooleG.task_workers, exit_worker);
}
}
}
//reload worker
kill_worker: if (manager_worker_reloading == 1)
{
//reload finish
if (reload_worker_i >= object->worker_num)
{
manager_worker_reloading = 0;
reload_worker_i = 0;
continue;
}
ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);
if (ret < 0)
{
swWarn("[Manager]kill fail.pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid, strerror(errno), errno);
continue;
}
reload_worker_i++;
}
}
sw_free(reload_workers);
return SW_OK;
}
static int swFactoryProcess_manager_loop(swFactory *factory)
{
int pid, new_pid;
int i;
int reload_worker_i = 0;
int ret;
int worker_exit_code;
SwooleG.use_signalfd = 0;
SwooleG.use_timerfd = 0;
swFactoryProcess *object = factory->object;
swServer *serv = factory->ptr;
swWorker *reload_workers;
if (serv->onManagerStart)
{
serv->onManagerStart(serv);
}
reload_workers = sw_calloc(serv->worker_num, sizeof(swWorker));
if (reload_workers == NULL)
{
swError("[manager] malloc[reload_workers] failed");
return SW_ERR;
}
//for reload
swSignal_add(SIGUSR1, swManagerSignalHanlde);
while (SwooleG.running > 0)
{
pid = wait(&worker_exit_code);
swTrace("[manager] worker stop.pid=%d\n", pid);
if (pid < 0)
{
if (manager_worker_reloading == 0)
{
swTrace("[Manager] wait failed. Error: %s [%d]", strerror(errno), errno);
}
else if (manager_reload_flag == 0)
{
memcpy(reload_workers, object->workers, sizeof(swWorker) * serv->worker_num);
manager_reload_flag = 1;
goto kill_worker;
}
}
if (SwooleG.running == 1)
{
for (i = 0; i < serv->worker_num; i++)
{
//对比pid
if (pid != object->workers[i].pid)
{
continue;
}
else
{
if(serv->onWorkerError!=NULL && WEXITSTATUS(worker_exit_code) > 0)
{
serv->onWorkerError(serv, i, pid, WEXITSTATUS(worker_exit_code));
}
pid = 0;
new_pid = swFactoryProcess_worker_spawn(factory, i);
if (new_pid < 0)
{
swWarn("Fork worker process failed. Error: %s [%d]", strerror(errno), errno);
return SW_ERR;
}
else
{
object->workers[i].pid = new_pid;
}
}
}
//task worker
if(pid > 0)
{
swWorker *exit_worker = swHashMap_find_int(&SwooleG.task_workers.map, pid);
if (exit_worker != NULL)
{
swProcessPool_spawn(exit_worker);
}
}
}
//reload worker
kill_worker: if (manager_worker_reloading == 1)
{
//reload finish
if (reload_worker_i >= serv->worker_num)
{
manager_worker_reloading = 0;
reload_worker_i = 0;
continue;
}
ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);
if (ret < 0)
{
swWarn("[Manager]kill failed, pid=%d. Error: %s [%d]", reload_workers[reload_worker_i].pid, strerror(errno), errno);
continue;
}
reload_worker_i++;
}
}
sw_free(reload_workers);
if (serv->onManagerStop)
{
serv->onManagerStop(serv);
}
return SW_OK;
}
static int swFactoryProcess_manager_loop(swFactory *factory)
{
int pid, new_pid;
int i;
int reload_worker_i = 0;
int reload_worker_num;
int ret;
int worker_exit_code;
SwooleG.use_signalfd = 0;
SwooleG.use_timerfd = 0;
memset(&ManagerProcess, 0, sizeof(ManagerProcess));
swServer *serv = factory->ptr;
swWorker *reload_workers;
if (serv->onManagerStart)
{
serv->onManagerStart(serv);
}
reload_worker_num = serv->worker_num + SwooleG.task_worker_num;
reload_workers = sw_calloc(reload_worker_num, sizeof(swWorker));
if (reload_workers == NULL)
{
swError("malloc[reload_workers] failed");
return SW_ERR;
}
//for reload
swSignal_add(SIGTERM, swManager_signal_handle);
swSignal_add(SIGUSR1, swManager_signal_handle);
swSignal_add(SIGUSR2, swManager_signal_handle);
//swSignal_add(SIGINT, swManager_signal_handle);
while (SwooleG.running > 0)
{
pid = wait(&worker_exit_code);
if (pid < 0)
{
if (ManagerProcess.reloading == 0)
{
swTrace("wait() failed. Error: %s [%d]", strerror(errno), errno);
}
else if (ManagerProcess.reload_event_worker == 1)
{
memcpy(reload_workers, serv->workers, sizeof(swWorker) * serv->worker_num);
reload_worker_num = serv->worker_num;
if (SwooleG.task_worker_num > 0)
{
memcpy(reload_workers + serv->worker_num, SwooleG.task_workers.workers,
sizeof(swWorker) * SwooleG.task_worker_num);
reload_worker_num += SwooleG.task_worker_num;
}
reload_worker_i = 0;
ManagerProcess.reload_event_worker = 0;
goto kill_worker;
}
else if (ManagerProcess.reload_task_worker == 1)
{
if (SwooleG.task_worker_num == 0)
{
swWarn("Cannot reload workers, because server no have task workers.");
continue;
}
memcpy(reload_workers, SwooleG.task_workers.workers, sizeof(swWorker) * SwooleG.task_worker_num);
reload_worker_num = SwooleG.task_worker_num;
reload_worker_i = 0;
ManagerProcess.reload_task_worker = 0;
goto kill_worker;
}
}
if (SwooleG.running == 1)
{
for (i = 0; i < serv->worker_num; i++)
{
//compare PID
if (pid != serv->workers[i].pid)
{
continue;
}
else
{
if (serv->onWorkerError != NULL && WEXITSTATUS(worker_exit_code) > 0)
{
serv->onWorkerError(serv, i, pid, WEXITSTATUS(worker_exit_code));
}
pid = 0;
while (1)
{
new_pid = swFactoryProcess_worker_spawn(factory, i);
if (new_pid < 0)
{
usleep(100000);
continue;
}
else
{
serv->workers[i].pid = new_pid;
break;
}
}
}
}
//task worker
if (pid > 0)
{
swWorker *exit_worker = swHashMap_find_int(SwooleG.task_workers.map, pid);
if (exit_worker != NULL)
{
swProcessPool_spawn(exit_worker);
}
}
}
//reload worker
kill_worker:
if (ManagerProcess.reloading == 1)
{
//reload finish
if (reload_worker_i >= reload_worker_num)
{
ManagerProcess.reloading = 0;
reload_worker_i = 0;
continue;
}
ret = kill(reload_workers[reload_worker_i].pid, SIGTERM);
if (ret < 0)
{
swSysError("[Manager]kill(%d) failed.", reload_workers[reload_worker_i].pid);
continue;
}
reload_worker_i++;
}
}
sw_free(reload_workers);
//kill all child process
for (i = 0; i < serv->worker_num; i++)
{
swTrace("[Manager]kill worker processor");
kill(serv->workers[i].pid, SIGTERM);
}
if (SwooleG.task_worker_num > 0)
{
swProcessPool_shutdown(&SwooleG.task_workers);
}
if (serv->onManagerStop)
{
serv->onManagerStop(serv);
}
return SW_OK;
}
