<?php
/**
* This file is part of workerman.
*
* Licensed under The MIT License
* For full copyright and license information, please see the MIT-LICENSE.txt
* Redistributions of files must retain the above copyright notice.
*
* @author walkor<walkor@workerman.net>
* @copyright walkor<walkor@workerman.net>
* @link http://www.workerman.net/
* @license http://www.opensource.org/licenses/mit-license.php MIT License
*/
namespace Workerman;
require_once __DIR__ . '/Lib/Constants.php';
use Workerman\Events\EventInterface;
use Workerman\Connection\ConnectionInterface;
use Workerman\Connection\TcpConnection;
use Workerman\Connection\UdpConnection;
use Workerman\Lib\Timer;
use Workerman\Events\Select;
use Exception;
/**
* Worker class
* A container for listening ports
*/
class Worker
{
/**
* 版本
*
* @var string
*/
const VERSION = '3.5.14';
/**
* 开始状态
*
* @var int
*/
const STATUS_STARTING = 1;
/**
* 运行状态
*
* @var int
*/
const STATUS_RUNNING = 2;
/**
* 关闭状态
*
* @var int
*/
const STATUS_SHUTDOWN = 4;
/**
* 重载状态
*
* @var int
*/
const STATUS_RELOADING = 8;
/**
* 将restart命令发送到子进程KILL_WORKER_TIMER_TIME秒后，
* 如果这个过程仍然存在则被迫杀死。
*
* @var int
*/
const KILL_WORKER_TIMER_TIME = 2;
/**
* Default backlog. Backlog is the maximum length of the queue of pending connections.
*
* @var int
*/
const DEFAULT_BACKLOG = 102400;
/**
* 最大udp包大小。
*
* @var int
*/
const MAX_UDP_PACKAGE_SIZE = 65535;
/**
* Worker id.
*
* @var int
*/
public $id = 0;
/**
* worker进程的名称
*
* @var string
*/
public $name = 'none';
/**
* worker进程数量
*
* @var int
*/
public $count = 1;
/**
* Unix用户的进程，需要适当的权限（通常是root）。
*
* @var string
*/
public $user = '';
/**
* Unix组的进程，需要适当的权限（通常是root）。
*
* @var string
*/
public $group = '';
/**
* 可重载的
*
* @var bool
*/
public $reloadable = true;
/**
* 重用端口。
*
* @var bool
*/
public $reusePort = false;
/**
* 工作进程启动时调用
*
* @var callback
*/
public $onWorkerStart = null;
/**
* 成功建立socket连接时调用。
*
* @var callback
*/
public $onConnect = null;
/**
* 接收数据时调用
*
* @var callback
*/
public $onMessage = null;
/**
* 当套接字的另一端发送FIN数据包时调用。
*
* @var callback
*/
public $onClose = null;
/**
* 连接发生错误时调用。
*
* @var callback
*/
public $onError = null;
/**
* 发送缓冲区变满时调用。
*
* @var callback
*/
public $onBufferFull = null;
/**
* 发送缓冲区为空时调用。
*
* @var callback
*/
public $onBufferDrain = null;
/**
* 工作进程停止时调用
*
* @var callback
*/
public $onWorkerStop = null;
/**
* 当worker进程获得重载信号时调用。
*
* @var callback
*/
public $onWorkerReload = null;
/**
* 传输层协议
*
* @var string
*/
public $transport = 'tcp';
/**
* 存储客户的所有连接。
*
* @var array
*/
public $connections = array();
/**
* 应用层协议
*
* @var string
*/
public $protocol = null;
/**
* 自动加载的根路径。
*
* @var string
*/
protected $_autoloadRootPath = '';
/**
* 暂停是否接受新连接。
*
* @var bool
*/
protected $_pauseAccept = true;
/**
* worker进程是否还在运行
* @var bool
*/
public $stopping = false;
/**
* 守护进程。
*
* @var bool
*/
public static $daemonize = false;
/**
* Stdout文件。
*
* @var string
*/
public static $stdoutFile = '/dev/null';
/**
* 用于存储主进程PID的文件。
*
* @var string
*/
public static $pidFile = '';
/**
* 日志文件。
*
* @var mixed
*/
public static $logFile = '';
/**
* 全局事件循环。
*
* @var Events\EventInterface
*/
public static $globalEvent = null;
/**
* 主进程获得重载信号时调用。
*
* @var callback
*/
public static $onMasterReload = null;
/**
* 主进程终止时调用。
*
* @var callback
*/
public static $onMasterStop = null;
/**
* EventLoopClass
*
* @var string
*/
public static $eventLoopClass = '';
/**
* 主进程的PID。
*
* @var int
*/
protected static $_masterPid = 0;
/**
* 监听socket
*
* @var resource
*/
protected $_mainSocket = null;
/**
* Socket名称. 格式像 http://0.0.0.0:80 .
*
* @var string
*/
protected $_socketName = '';
/**
* socket的上下文。
*
* @var resource
*/
protected $_context = null;
/**
* 所有worker进程实例
*
* @var Worker[]
*/
protected static $_workers = array();
/**
* 所有worker进程PID
* The format is like this [worker_id=>[pid=>pid, pid=>pid, ..], ..]
*
* @var array
*/
protected static $_pidMap = array();
/**
* 所有worker进程都在等待重启。
* The format is like this [pid=>pid, pid=>pid].
*
* @var array
*/
protected static $_pidsToRestart = array();
/**
* 从PID映射到worker进程ID。
* The format is like this [worker_id=>[0=>$pid, 1=>$pid, ..], ..].
*
* @var array
*/
protected static $_idMap = array();
/**
* 当前状态。
*
* @var int
*/
protected static $_status = self::STATUS_STARTING;
/**
* worker进程名称的最大长度
*
* @var int
*/
protected static $_maxWorkerNameLength = 12;
/**
* socket名称的最大长度
*
* @var int
*/
protected static $_maxSocketNameLength = 12;
/**
* 进程用户名的最大长度。
*
* @var int
*/
protected static $_maxUserNameLength = 12;
/**
* 用于存储当前worker进程的状态信息的文件。
*
* @var string
*/
protected static $_statisticsFile = '';
/**
* 开始文件。
*
* @var string
*/
protected static $_startFile = '';
/**
* 操作系统
*
* @var string
*/
protected static $_OS = OS_TYPE_LINUX;
/**
* Windows进程
*
* @var array
*/
protected static $_processForWindows = array();
/**
* 当前worker进程的状态信息。
*
* @var array
*/
protected static $_globalStatistics = array(
'start_timestamp' => 0,
'worker_exit_info' => array()
);
/**
* 可用的事件循环。
*
* @var array
*/
protected static $_availableEventLoops = array(
'libevent' => '\Workerman\Events\Libevent',
'event' => '\Workerman\Events\Event',
'swoole' => '\Workerman\Events\Swoole'
);
/**
* PHP内置协议
*
* @var array
*/
protected static $_builtinTransports = array(
'tcp' => 'tcp',
'udp' => 'udp',
'unix' => 'unix',
'ssl' => 'tcp'
);
/**
* 是否平滑重启
*
* @var string
*/
protected static $_gracefulStop = false;
/**
* 标准输出流
* @var resource
*/
protected static $_outputStream = null;
/**
* If $outputStream support decorated
* @var bool
*/
protected static $_outputDecorated = null;
/**
* 执行所有进程实例
*
* @return void
*/
public static function runAll()
{
static::checkSapiEnv();
static::init();
static::parseCommand();
static::daemonize();
static::initWorkers();
static::installSignal();
static::saveMasterPid();
static::displayUI();
static::forkWorkers();
static::resetStd();
static::monitorWorkers();
}
/**
* 检查sapi.
*
* @return void
*/
protected static function checkSapiEnv()
{
// Only for cli.
if (php_sapi_name() != "cli") {
exit("only run in command line mode \n");
}
if (DIRECTORY_SEPARATOR === '\\') {
self::$_OS = OS_TYPE_WINDOWS;
}
}
/**
* 初始化
*
* @return void
*/
protected static function init()
{
set_error_handler(function($code, $msg, $file, $line){
Worker::safeEcho("$msg in file $file on line $line\n");
});
// Start file.
$backtrace = debug_backtrace();
static::$_startFile = $backtrace[count($backtrace) - 1]['file'];
$unique_prefix = str_replace('/', '_', static::$_startFile);
// Pid file.
if (empty(static::$pidFile)) {
static::$pidFile = __DIR__ . "/../$unique_prefix.pid";
}
// Log file.
if (empty(static::$logFile)) {
static::$logFile = __DIR__ . '/../workerman.log';
}
$log_file = (string)static::$logFile;
if (!is_file($log_file)) {
touch($log_file);
chmod($log_file, 0622);
}
// State.
static::$_status = static::STATUS_STARTING;
// For statistics.
static::$_globalStatistics['start_timestamp'] = time();
static::$_statisticsFile = sys_get_temp_dir() . "/$unique_prefix.status";
// Process title.
static::setProcessTitle('WorkerMan: master process start_file=' . static::$_startFile);
// Init data for worker id.
static::initId();
// Timer init.
Timer::init();
}
/**
* 初始化所有进程实例
*
* @return void
*/
protected static function initWorkers()
{
if (static::$_OS !== OS_TYPE_LINUX) {
return;
}
foreach (static::$_workers as $worker) {
// Worker name.
if (empty($worker->name)) {
$worker->name = 'none';
}
// Get maximum length of worker name.
$worker_name_length = strlen($worker->name);
if (static::$_maxWorkerNameLength < $worker_name_length) {
static::$_maxWorkerNameLength = $worker_name_length;
}
// Get maximum length of socket name.
$socket_name_length = strlen($worker->getSocketName());
if (static::$_maxSocketNameLength < $socket_name_length) {
static::$_maxSocketNameLength = $socket_name_length;
}
// Get unix user of the worker process.
if (empty($worker->user)) {
$worker->user = static::getCurrentUser();
} else {
if (posix_getuid() !== 0 && $worker->user != static::getCurrentUser()) {
static::log('Warning: You must have the root privileges to change uid and gid.');
}
}
// Get maximum length of unix user name.
$user_name_length = strlen($worker->user);
if (static::$_maxUserNameLength < $user_name_length) {
static::$_maxUserNameLength = $user_name_length;
}
// Listen.
if (!$worker->reusePort) {
$worker->listen();
}
}
}
/**
* 获取所有worker进程实例
*
* @return array
*/
public static function getAllWorkers()
{
return static::$_workers;
}
/**
* 获取全局事件循环实例。
*
* @return EventInterface
*/
public static function getEventLoop()
{
return static::$globalEvent;
}
/**
* Init idMap.
* return void
*/
protected static function initId()
{
foreach (static::$_workers as $worker_id => $worker) {
$new_id_map = array();
$worker->count = $worker->count <= 0 ? 1 : $worker->count;
for($key = 0; $key < $worker->count; $key++) {
$new_id_map[$key] = isset(static::$_idMap[$worker_id][$key]) ? static::$_idMap[$worker_id][$key] : 0;
}
static::$_idMap[$worker_id] = $new_id_map;
}
}
/**
* 获取当前进程的unix用户。
*
* @return string
*/
protected static function getCurrentUser()
{
$user_info = posix_getpwuid(posix_getuid());
return $user_info['name'];
}
/**
* 显示开始UI界面
*
* @return void
*/
protected static function displayUI()
{
global $argv;
if (in_array('-q', $argv)) {
return;
}
if (static::$_OS !== OS_TYPE_LINUX) {
static::safeEcho("----------------------- WORKERMAN -----------------------------\r\n");
static::safeEcho('Workerman version:'. static::VERSION. " PHP version:". PHP_VERSION. "\r\n");
static::safeEcho("------------------------ WORKERS -------------------------------\r\n");
static::safeEcho("worker listen processes status\r\n");
return;
}
static::safeEcho("<n>-----------------------<w> WORKERMAN </w>-----------------------------</n>\r\n");
static::safeEcho('Workerman version:'. static::VERSION. " PHP version:". PHP_VERSION. "\r\n");
static::safeEcho("------------------------<w> WORKERS </w>-------------------------------\r\n");
static::safeEcho("<w>proto</w> <w>user</w>". str_pad('',
static::$_maxUserNameLength + 2 - strlen('user')). "<w>worker</w>". str_pad('',
static::$_maxWorkerNameLength + 2 - strlen('worker')). "<w>listen</w>". str_pad('',
static::$_maxSocketNameLength + 2 - strlen('listen')). "<w>processes</w> <w>status</w>\n");
foreach (static::$_workers as $worker) {
static::safeEcho(str_pad($worker->transport,9). str_pad($worker->user, static::$_maxUserNameLength + 2). str_pad($worker->name,
static::$_maxWorkerNameLength + 2). str_pad($worker->getSocketName(),
static::$_maxSocketNameLength + 2). str_pad(' ' . $worker->count, 9). " <g> [OK] </g>\n");
}
static::safeEcho("----------------------------------------------------------------\n");
if (static::$daemonize) {
static::safeEcho("Input \"php $argv[0] stop\" to stop. Start success.\n\n");
} else {
static::safeEcho("Press Ctrl+C to stop. Start success.\n");
}
}
/**
* 解析命令。
*
* @return void
*/
protected static function parseCommand()
{
if (static::$_OS !== OS_TYPE_LINUX) {
return;
}
global $argv;
// 检查参数
$start_file = $argv[0];
$available_commands = array(
'start',
'stop',
'restart',
'reload',
'status',
'connections',
);
$usage = "Usage: php yourfile <command> [mode]\nCommands: \nstart\t\tStart worker in DEBUG mode.\n\t\tUse mode -d to start in DAEMON mode.\nstop\t\tStop worker.\n\t\tUse mode -g to stop gracefully.\nrestart\t\tRestart workers.\n\t\tUse mode -d to start in DAEMON mode.\n\t\tUse mode -g to stop gracefully.\nreload\t\tReload codes.\n\t\tUse mode -g to reload gracefully.\nstatus\t\tGet worker status.\n\t\tUse mode -d to show live status.\nconnections\tGet worker connections.\n";
if (!isset($argv[1]) || !in_array($argv[1], $available_commands)) {
if (isset($argv[1])) {
static::safeEcho('Unknown command: ' . $argv[1] . "\n");
}
exit($usage);
}
// 获取命令
$command = trim($argv[1]);
$command2 = isset($argv[2]) ? $argv[2] : '';
// 开始命令
$mode = '';
if ($command === 'start') {
if ($command2 === '-d' || static::$daemonize) {
$mode = 'in DAEMON mode';
} else {
$mode = 'in DEBUG mode';
}
}
static::log("Workerman[$start_file] $command $mode");
// 获取主进程PID。
$master_pid = is_file(static::$pidFile) ? file_get_contents(static::$pidFile) : 0;
$master_is_alive = $master_pid && posix_kill($master_pid, 0) && posix_getpid() != $master_pid;
// Master is still alive?
if ($master_is_alive) {
if ($command === 'start') {
static::log("Workerman[$start_file] already running");
exit;
}
} elseif ($command !== 'start' && $command !== 'restart') {
static::log("Workerman[$start_file] not run");
exit;
}
// 执行命令。
switch ($command) {
case 'start':
if ($command2 === '-d') {
static::$daemonize = true;
}
break;
case 'status':
while (1) {
if (is_file(static::$_statisticsFile)) {
@unlink(static::$_statisticsFile);
}
// 主进程将向所有子进程发送SIGUSR2信号。
posix_kill($master_pid, SIGUSR2);
// 休眠1秒
sleep(1);
// 清除终端
if ($command2 === '-d') {
static::safeEcho("\33[H\33[2J\33(B\33[m", true);
}
// 输出状态数据
static::safeEcho(static::formatStatusData());
if ($command2 !== '-d') {
exit(0);
}
static::safeEcho("\nPress Ctrl+C to quit.\n\n");
}
exit(0);
case 'connections':
if (is_file(static::$_statisticsFile) && is_writable(static::$_statisticsFile)) {
unlink(static::$_statisticsFile);
}
// Master process will send SIGIO signal to all child processes.
posix_kill($master_pid, SIGIO);
// Waiting amoment.
usleep(500000);
// Display statisitcs data from a disk file.
if(is_readable(static::$_statisticsFile)) {
readfile(static::$_statisticsFile);
}
exit(0);
case 'restart':
case 'stop':
if ($command2 === '-g') {
static::$_gracefulStop = true;
$sig = SIGTERM;
static::log("Workerman[$start_file] is gracefully stopping ...");
} else {
static::$_gracefulStop = false;
$sig = SIGINT;
static::log("Workerman[$start_file] is stopping ...");
}
// Send stop signal to master process.
$master_pid && posix_kill($master_pid, $sig);
// Timeout.
$timeout = 5;
$start_time = time();
// Check master process is still alive?
while (1) {
$master_is_alive = $master_pid && posix_kill($master_pid, 0);
if ($master_is_alive) {
// Timeout?
if (!static::$_gracefulStop && time() - $start_time >= $timeout) {
static::log("Workerman[$start_file] stop fail");
exit;
}
// Waiting amoment.
usleep(10000);
continue;
}
// Stop success.
static::log("Workerman[$start_file] stop success");
if ($command === 'stop') {
exit(0);
}
if ($command2 === '-d') {
static::$daemonize = true;
}
break;
}
break;
case 'reload':
if($command2 === '-g'){
$sig = SIGQUIT;
}else{
$sig = SIGUSR1;
}
posix_kill($master_pid, $sig);
exit;
default :
if (isset($command)) {
static::safeEcho('Unknown command: ' . $command . "\n");
}
exit($usage);
}
}
/**
* 格式化状态数据。
*
* @return string
*/
protected static function formatStatusData()
{
static $total_request_cache = array();
if (!is_readable(static::$_statisticsFile)) {
return '';
}
$info = file(static::$_statisticsFile, FILE_IGNORE_NEW_LINES);
if (!$info) {
return '';
}
$status_str = '';
$current_total_request = array();
$worker_info = json_decode($info[0], true);
ksort($worker_info, SORT_NUMERIC);
unset($info[0]);
$data_waiting_sort = array();
$read_process_status = false;
$total_requests = 0;
$total_qps = 0;
$total_connections = 0;
$total_fails = 0;
$total_memory = 0;
$total_timers = 0;
$maxLen1 = static::$_maxSocketNameLength;
$maxLen2 = static::$_maxWorkerNameLength;
foreach($info as $key => $value) {
if (!$read_process_status) {
$status_str .= $value . "\n";
if (preg_match('/^pid.*?memory.*?listening/', $value)) {
$read_process_status = true;
}
continue;
}
if(preg_match('/^[0-9]+/', $value, $pid_math)) {
$pid = $pid_math[0];
$data_waiting_sort[$pid] = $value;
if(preg_match('/^\S+?\s+?(\S+?)\s+?(\S+?)\s+?(\S+?)\s+?(\S+?)\s+?(\S+?)\s+?(\S+?)\s+?(\S+?)\s+?/', $value, $match)) {
$total_memory += intval(str_ireplace('M','',$match[1]));
$maxLen1 = max($maxLen1,strlen($match[2]));
$maxLen2 = max($maxLen2,strlen($match[3]));
$total_connections += intval($match[4]);
$total_fails += intval($match[5]);
$total_timers += intval($match[6]);
$current_total_request[$pid] = $match[7];
$total_requests += intval($match[7]);
}
}
}
foreach($worker_info as $pid => $info) {
if (!isset($data_waiting_sort[$pid])) {
$status_str .= "$pid\t" . str_pad('N/A', 7) . " "
. str_pad($info['listen'], static::$_maxSocketNameLength) . " "
. str_pad($info['name'], static::$_maxWorkerNameLength) . " "
. str_pad('N/A', 11) . " " . str_pad('N/A', 9) . " "
. str_pad('N/A', 7) . " " . str_pad('N/A', 13) . " N/A [busy] \n";
continue;
}
//$qps = isset($total_request_cache[$pid]) ? $current_total_request[$pid]
if (!isset($total_request_cache[$pid]) || !isset($current_total_request[$pid])) {
$qps = 0;
} else {
$qps = $current_total_request[$pid] - $total_request_cache[$pid];
$total_qps += $qps;
}
$status_str .= $data_waiting_sort[$pid]. " " . str_pad($qps, 6) ." [idle]\n";
}
$total_request_cache = $current_total_request;
$status_str .= "----------------------------------------------PROCESS STATUS---------------------------------------------------\n";
$status_str .= "Summary\t" . str_pad($total_memory.'M', 7) . " "
. str_pad('-', $maxLen1) . " "
. str_pad('-', $maxLen2) . " "
. str_pad($total_connections, 11) . " " . str_pad($total_fails, 9) . " "
. str_pad($total_timers, 7) . " " . str_pad($total_requests, 13) . " "
. str_pad($total_qps,6)." [Summary] \n";
return $status_str;
}
/**
* 安装信号处理程序
*
* @return void
*/
protected static function installSignal()
{
if (static::$_OS !== OS_TYPE_LINUX) {
return;
}
// stop
pcntl_signal(SIGINT, array('\Workerman\Worker', 'signalHandler'), false);
// graceful stop
pcntl_signal(SIGTERM, array('\Workerman\Worker', 'signalHandler'), false);
// reload
pcntl_signal(SIGUSR1, array('\Workerman\Worker', 'signalHandler'), false);
// graceful reload
pcntl_signal(SIGQUIT, array('\Workerman\Worker', 'signalHandler'), false);
// status
pcntl_signal(SIGUSR2, array('\Workerman\Worker', 'signalHandler'), false);
// connection status
pcntl_signal(SIGIO, array('\Workerman\Worker', 'signalHandler'), false);
// ignore
pcntl_signal(SIGPIPE, SIG_IGN, false);
}
/**
* 重新安装信号处理程序
*
* @return void
*/
protected static function reinstallSignal()
{
if (static::$_OS !== OS_TYPE_LINUX) {
return;
}
// uninstall stop signal handler
pcntl_signal(SIGINT, SIG_IGN, false);
// uninstall graceful stop signal handler
pcntl_signal(SIGTERM, SIG_IGN, false);
// uninstall reload signal handler
pcntl_signal(SIGUSR1, SIG_IGN, false);
// uninstall graceful reload signal handler
pcntl_signal(SIGQUIT, SIG_IGN, false);
// uninstall status signal handler
pcntl_signal(SIGUSR2, SIG_IGN, false);
// reinstall stop signal handler
static::$globalEvent->add(SIGINT, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
// reinstall graceful stop signal handler
static::$globalEvent->add(SIGTERM, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
// reinstall reload signal handler
static::$globalEvent->add(SIGUSR1, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
// reinstall graceful reload signal handler
static::$globalEvent->add(SIGQUIT, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
// reinstall status signal handler
static::$globalEvent->add(SIGUSR2, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
// reinstall connection status signal handler
static::$globalEvent->add(SIGIO, EventInterface::EV_SIGNAL, array('\Workerman\Worker', 'signalHandler'));
}
/**
* 信号处理器。
*
* @param int $signal
*/
public static function signalHandler($signal)
{
switch ($signal) {
// Stop.
case SIGINT:
static::$_gracefulStop = false;
static::stopAll();
break;
// Graceful stop.
case SIGTERM:
static::$_gracefulStop = true;
static::stopAll();
break;
// Reload.
case SIGQUIT:
case SIGUSR1:
if($signal === SIGQUIT){
static::$_gracefulStop = true;
}else{
static::$_gracefulStop = false;
}
static::$_pidsToRestart = static::getAllWorkerPids();
static::reload();
break;
// Show status.
case SIGUSR2:
static::writeStatisticsToStatusFile();
break;
// Show connection status.
case SIGIO:
static::writeConnectionsStatisticsToStatusFile();
break;
}
}
/**
* 作为守护进程模式运行。
*
* @throws Exception
*/
protected static function daemonize()
{
if (!static::$daemonize || static::$_OS !== OS_TYPE_LINUX) {
return;
}
umask(0);
$pid = pcntl_fork();
if (-1 === $pid) {
throw new Exception('fork fail');
} elseif ($pid > 0) {
exit(0);
}
if (-1 === posix_setsid()) {
throw new Exception("setsid fail");
}
// Fork again avoid SVR4 system regain the control of terminal.
$pid = pcntl_fork();
if (-1 === $pid) {
throw new Exception("fork fail");
} elseif (0 !== $pid) {
exit(0);
}
}
/**
* 重定向标准输入和输出。
*
* @throws Exception
*/
public static function resetStd()
{
if (!static::$daemonize || static::$_OS !== OS_TYPE_LINUX) {
return;
}
global $STDOUT, $STDERR;
$handle = fopen(static::$stdoutFile, "a");
if ($handle) {
unset($handle);
set_error_handler(function(){});
fclose($STDOUT);
fclose($STDERR);
fclose(STDOUT);
fclose(STDERR);
$STDOUT = fopen(static::$stdoutFile, "a");
$STDERR = fopen(static::$stdoutFile, "a");
// change output stream
static::$_outputStream = null;
static::outputStream($STDOUT);
restore_error_handler();
} else {
throw new Exception('can not open stdoutFile ' . static::$stdoutFile);
}
}
/**
* 保存pid.
*
* @throws Exception
*/
protected static function saveMasterPid()
{
if (static::$_OS !== OS_TYPE_LINUX) {
return;
}
static::$_masterPid = posix_getpid();
if (false === file_put_contents(static::$pidFile, static::$_masterPid)) {
throw new Exception('can not save pid to ' . static::$pidFile);
}
}
/**
* 获取事件循环名称。
*
* @return string
*/
protected static function getEventLoopName()
{
if (static::$eventLoopClass) {
return static::$eventLoopClass;
}
if (!class_exists('\Swoole\Event')) {
unset(static::$_availableEventLoops['swoole']);
}
$loop_name = '';
foreach (static::$_availableEventLoops as $name=>$class) {
if (extension_loaded($name)) {
$loop_name = $name;
break;
}
}
if ($loop_name) {
if (interface_exists('\React\EventLoop\LoopInterface')) {
switch ($loop_name) {
case 'libevent':
static::$eventLoopClass = '\Workerman\Events\React\ExtLibEventLoop';
break;
case 'event':
static::$eventLoopClass = '\Workerman\Events\React\ExtEventLoop';
break;
default :
static::$eventLoopClass = '\Workerman\Events\React\StreamSelectLoop';
break;
}
} else {
static::$eventLoopClass = static::$_availableEventLoops[$loop_name];
}
} else {
static::$eventLoopClass = interface_exists('\React\EventLoop\LoopInterface')? '\Workerman\Events\React\StreamSelectLoop':'\Workerman\Events\Select';
}
return static::$eventLoopClass;
}
/**
* 获取所有worker进程的pids。
*
* @return array
*/
protected static function getAllWorkerPids()
{
$pid_array = array();
foreach (static::$_pidMap as $worker_pid_array) {
foreach ($worker_pid_array as $worker_pid) {
$pid_array[$worker_pid] = $worker_pid;
}
}
return $pid_array;
}
/**
* Fork some worker processes.
*
* @return void
*/
protected static function forkWorkers()
{
if (static::$_OS === OS_TYPE_LINUX) {
static::forkWorkersForLinux();
} else {
static::forkWorkersForWindows();
}
}
/**
* Fork some worker processes.
*
* @return void
*/
protected static function forkWorkersForLinux()
{
foreach (static::$_workers as $worker) {
if (static::$_status === static::STATUS_STARTING) {
if (empty($worker->name)) {
$worker->name = $worker->getSocketName();
}
$worker_name_length = strlen($worker->name);
if (static::$_maxWorkerNameLength < $worker_name_length) {
static::$_maxWorkerNameLength = $worker_name_length;
}
}
while (count(static::$_pidMap[$worker->workerId]) < $worker->count) {
static::forkOneWorkerForLinux($worker);
}
}
}
/**
* Fork some worker processes.
*
* @return void
*/
protected static function forkWorkersForWindows()
{
$files = static::getStartFilesForWindows();
global $argv;
if(in_array('-q', $argv) || count($files) === 1)
{
if(count(static::$_workers) > 1)
{
static::safeEcho("@@@ Error: multi workers init in one php file are not support @@@\r\n");
static::safeEcho("@@@ Please visit http://wiki.workerman.net/Multi_woker_for_win @@@\r\n");
}
elseif(count(static::$_workers) <= 0)
{
exit("@@@no worker inited@@@\r\n\r\n");
}
reset(static::$_workers);
/** @var Worker $worker */
$worker = current(static::$_workers);
// Display UI.
static::safeEcho(str_pad($worker->name, 21) . str_pad($worker->getSocketName(), 36) . str_pad($worker->count, 10) . "[ok]\n");
$worker->listen();
$worker->run();
exit("@@@child exit@@@\r\n");
}
else
{
static::$globalEvent = new \Workerman\Events\Select();
Timer::init(static::$globalEvent);
foreach($files as $start_file)
{
static::forkOneWorkerForWindows($start_file);
}
}
}
/**
* 获取Windows的启动文件。
*
* @return array
*/
public static function getStartFilesForWindows() {
global $argv;
$files = array();
foreach($argv as $file)
{
if(is_file($file))
{
$files[$file] = $file;
}
}
return $files;
}
/**
* Fork one worker process.
*
* @param string $start_file
*/
public static function forkOneWorkerForWindows($start_file)
{
$start_file = realpath($start_file);
$std_file = sys_get_temp_dir() . '/'.str_replace(array('/', "\\", ':'), '_', $start_file).'.out.txt';
$descriptorspec = array(
0 => array('pipe', 'a'), // stdin
1 => array('file', $std_file, 'w'), // stdout
2 => array('file', $std_file, 'w') // stderr
);
$pipes = array();
$process = proc_open("php \"$start_file\" -q", $descriptorspec, $pipes);
$std_handler = fopen($std_file, 'a+');
stream_set_blocking($std_handler, 0);
if (empty(static::$globalEvent)) {
static::$globalEvent = new Select();
Timer::init(static::$globalEvent);
}
$timer_id = Timer::add(0.1, function()use($std_handler)
{
Worker::safeEcho(fread($std_handler, 65535));
});
// 保存子进程句柄
static::$_processForWindows[$start_file] = array($process, $start_file, $timer_id);
}
/**
* 检查Windows的worker进程状态。
* @return void
*/
public static function checkWorkerStatusForWindows()
{
foreach(static::$_processForWindows as $process_data)
{
$process = $process_data[0];
$start_file = $process_data[1];
$timer_id = $process_data[2];
$status = proc_get_status($process);
if(isset($status['running']))
{
if(!$status['running'])
{
static::safeEcho("process $start_file terminated and try to restart\n");
Timer::del($timer_id);
proc_close($process);
static::forkOneWorkerForWindows($start_file);
}
}
else
{
static::safeEcho("proc_get_status fail\n");
}
}
}
/**
* Fork one worker process.
*
* @param \Workerman\Worker $worker
* @throws Exception
*/
protected static function forkOneWorkerForLinux($worker)
{
// Get available worker id.
$id = static::getId($worker->workerId, 0);
if ($id === false) {
return;
}
$pid = pcntl_fork();
// For master process.
if ($pid > 0) {
static::$_pidMap[$worker->workerId][$pid] = $pid;
static::$_idMap[$worker->workerId][$id] = $pid;
} // For child processes.
elseif (0 === $pid) {
if ($worker->reusePort) {
$worker->listen();
}
if (static::$_status === static::STATUS_STARTING) {
static::resetStd();
}
static::$_pidMap = array();
// Remove other listener.
foreach(static::$_workers as $key => $one_worker) {
if ($one_worker->workerId !== $worker->workerId) {
$one_worker->unlisten();
unset(static::$_workers[$key]);
}
}
Timer::delAll();
static::setProcessTitle('WorkerMan: worker process ' . $worker->name . ' ' . $worker->getSocketName());
$worker->setUserAndGroup();
$worker->id = $id;
$worker->run();
$err = new Exception('event-loop exited');
static::log($err);
exit(250);
} else {
throw new Exception("forkOneWorker fail");
}
}
/**
* 获取worker id.
*
* @param int $worker_id
* @param int $pid
*
* @return integer
*/
protected static function getId($worker_id, $pid)
{
return array_search($pid, static::$_idMap[$worker_id]);
}
/**
* 为当前进程设置unix用户和组。
*
* @return void
*/
public function setUserAndGroup()
{
// Get uid.
$user_info = posix_getpwnam($this->user);
if (!$user_info) {
static::log("Warning: User {$this->user} not exsits");
return;
}
$uid = $user_info['uid'];
// Get gid.
if ($this->group) {
$group_info = posix_getgrnam($this->group);
if (!$group_info) {
static::log("Warning: Group {$this->group} not exsits");
return;
}
$gid = $group_info['gid'];
} else {
$gid = $user_info['gid'];
}
// Set uid and gid.
if ($uid != posix_getuid() || $gid != posix_getgid()) {
if (!posix_setgid($gid) || !posix_initgroups($user_info['name'], $gid) || !posix_setuid($uid)) {
static::log("Warning: change gid or uid fail.");
}
}
}
/**
* 设置进程名。
*
* @param string $title
* @return void
*/
protected static function setProcessTitle($title)
{
set_error_handler(function(){});
// >=php 5.5
if (function_exists('cli_set_process_title')) {
cli_set_process_title($title);
} // Need proctitle when php<=5.5 .
elseif (extension_loaded('proctitle') && function_exists('setproctitle')) {
setproctitle($title);
}
restore_error_handler();
}
/**
* 监听所有子进程。
*
* @return void
*/
protected static function monitorWorkers()
{
if (static::$_OS === OS_TYPE_LINUX) {
static::monitorWorkersForLinux();
} else {
static::monitorWorkersForWindows();
}
}
/**
* 监听所有Linux子进程
*
* @return void
*/
protected static function monitorWorkersForLinux()
{
static::$_status = static::STATUS_RUNNING;
while (1) {
// Calls signal handlers for pending signals.
pcntl_signal_dispatch();
// Suspends execution of the current process until a child has exited, or until a signal is delivered
$status = 0;
$pid = pcntl_wait($status, WUNTRACED);
// Calls signal handlers for pending signals again.
pcntl_signal_dispatch();
// If a child has already exited.
if ($pid > 0) {
// Find out witch worker process exited.
foreach (static::$_pidMap as $worker_id => $worker_pid_array) {
if (isset($worker_pid_array[$pid])) {
$worker = static::$_workers[$worker_id];
// Exit status.
if ($status !== 0) {
static::log("worker[" . $worker->name . ":$pid] exit with status $status");
}
// For Statistics.
if (!isset(static::$_globalStatistics['worker_exit_info'][$worker_id][$status])) {
static::$_globalStatistics['worker_exit_info'][$worker_id][$status] = 0;
}
static::$_globalStatistics['worker_exit_info'][$worker_id][$status]++;
// Clear process data.
unset(static::$_pidMap[$worker_id][$pid]);
// Mark id is available.
$id = static::getId($worker_id, $pid);
static::$_idMap[$worker_id][$id] = 0;
break;
}
}
// Is still running state then fork a new worker process.
if (static::$_status !== static::STATUS_SHUTDOWN) {
static::forkWorkers();
// If reloading continue.
if (isset(static::$_pidsToRestart[$pid])) {
unset(static::$_pidsToRestart[$pid]);
static::reload();
}
} else {
// If shutdown state and all child processes exited then master process exit.
if (!static::getAllWorkerPids()) {
static::exitAndClearAll();
}
}
} else {
// If shutdown state and all child processes exited then master process exit.
if (static::$_status === static::STATUS_SHUTDOWN && !static::getAllWorkerPids()) {
static::exitAndClearAll();
}
}
}
}
/**
* Monitor all child processes.
*
* @return void
*/
protected static function monitorWorkersForWindows()
{
Timer::add(1, "\\Workerman\\Worker::checkWorkerStatusForWindows");
static::$globalEvent->loop();
}
/**
* 终止当前进程
*
* @return void
*/
protected static function exitAndClearAll()
{
foreach (static::$_workers as $worker) {
$socket_name = $worker->getSocketName();
if ($worker->transport === 'unix' && $socket_name) {
list(, $address) = explode(':', $socket_name, 2);
@unlink($address);
}
}
@unlink(static::$pidFile);
static::log("Workerman[" . basename(static::$_startFile) . "] has been stopped");
if (static::$onMasterStop) {
call_user_func(static::$onMasterStop);
}
exit(0);
}
/**
* 执行重载
*
* @return void
*/
protected static function reload()
{
// For master process.
if (static::$_masterPid === posix_getpid()) {
// Set reloading state.
if (static::$_status !== static::STATUS_RELOADING && static::$_status !== static::STATUS_SHUTDOWN) {
static::log("Workerman[" . basename(static::$_startFile) . "] reloading");
static::$_status = static::STATUS_RELOADING;
// Try to emit onMasterReload callback.
if (static::$onMasterReload) {
try {
call_user_func(static::$onMasterReload);
} catch (\Exception $e) {
static::log($e);
exit(250);
} catch (\Error $e) {
static::log($e);
exit(250);
}
static::initId();
}
}
if (static::$_gracefulStop) {
$sig = SIGQUIT;
} else {
$sig = SIGUSR1;
}
// Send reload signal to all child processes.
$reloadable_pid_array = array();
foreach (static::$_pidMap as $worker_id => $worker_pid_array) {
$worker = static::$_workers[$worker_id];
if ($worker->reloadable) {
foreach ($worker_pid_array as $pid) {
$reloadable_pid_array[$pid] = $pid;
}
} else {
foreach ($worker_pid_array as $pid) {
// Send reload signal to a worker process which reloadable is false.
posix_kill($pid, $sig);
}
}
}
// Get all pids that are waiting reload.
static::$_pidsToRestart = array_intersect(static::$_pidsToRestart, $reloadable_pid_array);
// Reload complete.
if (empty(static::$_pidsToRestart)) {
if (static::$_status !== static::STATUS_SHUTDOWN) {
static::$_status = static::STATUS_RUNNING;
}
return;
}
// Continue reload.
$one_worker_pid = current(static::$_pidsToRestart);
// Send reload signal to a worker process.
posix_kill($one_worker_pid, $sig);
// If the process does not exit after static::KILL_WORKER_TIMER_TIME seconds try to kill it.
if(!static::$_gracefulStop){
Timer::add(static::KILL_WORKER_TIMER_TIME, 'posix_kill', array($one_worker_pid, SIGKILL), false);
}
} // For child processes.
else {
reset(static::$_workers);
$worker = current(static::$_workers);
// Try to emit onWorkerReload callback.
if ($worker->onWorkerReload) {
try {
call_user_func($worker->onWorkerReload, $worker);
} catch (\Exception $e) {
static::log($e);
exit(250);
} catch (\Error $e) {
static::log($e);
exit(250);
}
}
if ($worker->reloadable) {
static::stopAll();
}
}
}
/**
* 停止
*
* @return void
*/
public static function stopAll()
{
static::$_status = static::STATUS_SHUTDOWN;
// For master process.
if (static::$_masterPid === posix_getpid()) {
static::log("Workerman[" . basename(static::$_startFile) . "] stopping ...");
$worker_pid_array = static::getAllWorkerPids();
// Send stop signal to all child processes.
if (static::$_gracefulStop) {
$sig = SIGTERM;
} else {
$sig = SIGINT;
}
foreach ($worker_pid_array as $worker_pid) {
posix_kill($worker_pid, $sig);
if(!static::$_gracefulStop){
Timer::add(static::KILL_WORKER_TIMER_TIME, 'posix_kill', array($worker_pid, SIGKILL), false);
}
}
Timer::add(1, "\\Workerman\\Worker::checkIfChildRunning");
// Remove statistics file.
if (is_file(static::$_statisticsFile)) {
@unlink(static::$_statisticsFile);
}
} // For child processes.
else {
// Execute exit.
foreach (static::$_workers as $worker) {
if(!$worker->stopping){
$worker->stop();
$worker->stopping = true;
}
}
if (!static::$_gracefulStop || ConnectionInterface::$statistics['connection_count'] <= 0) {
static::$_workers = array();
if (static::$globalEvent) {
static::$globalEvent->destroy();
}
exit(0);
}
}
}
/**
* 检查子进程是否真的在运行
*/
public static function checkIfChildRunning()
{
foreach (static::$_pidMap as $worker_id => $worker_pid_array) {
foreach ($worker_pid_array as $pid => $worker_pid) {
if (!posix_kill($pid, 0)) {
unset(static::$_pidMap[$worker_id][$pid]);
}
}
}
}
/**
* 获取进程状态。
*
* @return number
*/
public static function getStatus()
{
return static::$_status;
}
/**
* 是否平滑停止
*
* @return boolean
*/
public static function getGracefulStop()
{
return static::$_gracefulStop;
}
/**
* 将统计数据写入磁盘。
*
* @return void
*/
protected static function writeStatisticsToStatusFile()
{
// For master process.
if (static::$_masterPid === posix_getpid()) {
$all_worker_info = array();
foreach(static::$_pidMap as $worker_id => $pid_array) {
/** @var /Workerman/Worker $worker */
$worker = static::$_workers[$worker_id];
foreach($pid_array as $pid) {
$all_worker_info[$pid] = array('name' => $worker->name, 'listen' => $worker->getSocketName());
}
}
file_put_contents(static::$_statisticsFile, json_encode($all_worker_info)."\n", FILE_APPEND);
$loadavg = function_exists('sys_getloadavg') ? array_map('round', sys_getloadavg(), array(2)) : array('-', '-', '-');
file_put_contents(static::$_statisticsFile,
"----------------------------------------------GLOBAL STATUS----------------------------------------------------\n", FILE_APPEND);
file_put_contents(static::$_statisticsFile,
'Workerman version:' . static::VERSION . " PHP version:" . PHP_VERSION . "\n", FILE_APPEND);
file_put_contents(static::$_statisticsFile, 'start time:' . date('Y-m-d H:i:s',
static::$_globalStatistics['start_timestamp']) . ' run ' . floor((time() - static::$_globalStatistics['start_timestamp']) / (24 * 60 * 60)) . ' days ' . floor(((time() - static::$_globalStatistics['start_timestamp']) % (24 * 60 * 60)) / (60 * 60)) . " hours \n",
FILE_APPEND);
$load_str = 'load average: ' . implode(", ", $loadavg);
file_put_contents(static::$_statisticsFile,
str_pad($load_str, 33) . 'event-loop:' . static::getEventLoopName() . "\n", FILE_APPEND);
file_put_contents(static::$_statisticsFile,
count(static::$_pidMap) . ' workers ' . count(static::getAllWorkerPids()) . " processes\n",
FILE_APPEND);
file_put_contents(static::$_statisticsFile,
str_pad('worker_name', static::$_maxWorkerNameLength) . " exit_status exit_count\n", FILE_APPEND);
foreach (static::$_pidMap as $worker_id => $worker_pid_array) {
$worker = static::$_workers[$worker_id];
if (isset(static::$_globalStatistics['worker_exit_info'][$worker_id])) {
foreach (static::$_globalStatistics['worker_exit_info'][$worker_id] as $worker_exit_status => $worker_exit_count) {
file_put_contents(static::$_statisticsFile,
str_pad($worker->name, static::$_maxWorkerNameLength) . " " . str_pad($worker_exit_status,
16) . " $worker_exit_count\n", FILE_APPEND);
}
} else {
file_put_contents(static::$_statisticsFile,
str_pad($worker->name, static::$_maxWorkerNameLength) . " " . str_pad(0, 16) . " 0\n",
FILE_APPEND);
}
}
file_put_contents(static::$_statisticsFile,
"----------------------------------------------PROCESS STATUS---------------------------------------------------\n",
FILE_APPEND);
file_put_contents(static::$_statisticsFile,
"pid\tmemory " . str_pad('listening', static::$_maxSocketNameLength) . " " . str_pad('worker_name',
static::$_maxWorkerNameLength) . " connections " . str_pad('send_fail', 9) . " "
. str_pad('timers', 8) . str_pad('total_request', 13) ." qps status\n", FILE_APPEND);
chmod(static::$_statisticsFile, 0722);
foreach (static::getAllWorkerPids() as $worker_pid) {
posix_kill($worker_pid, SIGUSR2);
}
return;
}
// For child processes.
reset(static::$_workers);
/** @var \Workerman\Worker $worker */
$worker = current(static::$_workers);
$worker_status_str = posix_getpid() . "\t" . str_pad(round(memory_get_usage(true) / (1024 * 1024), 2) . "M", 7)
. " " . str_pad($worker->getSocketName(), static::$_maxSocketNameLength) . " "
. str_pad(($worker->name === $worker->getSocketName() ? 'none' : $worker->name), static::$_maxWorkerNameLength)
. " ";
$worker_status_str .= str_pad(ConnectionInterface::$statistics['connection_count'], 11)
. " " . str_pad(ConnectionInterface::$statistics['send_fail'], 9)
. " " . str_pad(static::$globalEvent->getTimerCount(), 7)
. " " . str_pad(ConnectionInterface::$statistics['total_request'], 13) . "\n";
file_put_contents(static::$_statisticsFile, $worker_status_str, FILE_APPEND);
}
/**
* 将统计数据写入磁盘。
*
* @return void
*/
protected static function writeConnectionsStatisticsToStatusFile()
{
// For master process.
if (static::$_masterPid === posix_getpid()) {
file_put_contents(static::$_statisticsFile, "--------------------------------------------------------------------- WORKERMAN CONNECTION STATUS --------------------------------------------------------------------------------\n", FILE_APPEND);
file_put_contents(static::$_statisticsFile, "PID Worker CID Trans Protocol ipv4 ipv6 Recv-Q Send-Q Bytes-R Bytes-W Status Local Address Foreign Address\n", FILE_APPEND);
chmod(static::$_statisticsFile, 0722);
foreach (static::getAllWorkerPids() as $worker_pid) {
posix_kill($worker_pid, SIGIO);
}
return;
}
// For child processes.
$bytes_format = function($bytes)
{
if($bytes > 1024*1024*1024*1024) {
return round($bytes/(1024*1024*1024*1024), 1)."TB";
}
if($bytes > 1024*1024*1024) {
return round($bytes/(1024*1024*1024), 1)."GB";
}
if($bytes > 1024*1024) {
return round($bytes/(1024*1024), 1)."MB";
}
if($bytes > 1024) {
return round($bytes/(1024), 1)."KB";
}
return $bytes."B";
};
$pid = posix_getpid();
$str = '';
reset(static::$_workers);
$current_worker = current(static::$_workers);
$default_worker_name = $current_worker->name;
/** @var \Workerman\Worker $worker */
foreach(TcpConnection::$connections as $connection) {
/** @var \Workerman\Connection\TcpConnection $connection */
$transport = $connection->transport;
$ipv4 = $connection->isIpV4() ? ' 1' : ' 0';
$ipv6 = $connection->isIpV6() ? ' 1' : ' 0';
$recv_q = $bytes_format($connection->getRecvBufferQueueSize());
$send_q = $bytes_format($connection->getSendBufferQueueSize());
$local_address = trim($connection->getLocalAddress());
$remote_address = trim($connection->getRemoteAddress());
$state = $connection->getStatus(false);
$bytes_read = $bytes_format($connection->bytesRead);
$bytes_written = $bytes_format($connection->bytesWritten);
$id = $connection->id;
$protocol = $connection->protocol ? $connection->protocol : $connection->transport;
$pos = strrpos($protocol, '\\');
if ($pos) {
$protocol = substr($protocol, $pos+1);
}
if (strlen($protocol) > 15) {
$protocol = substr($protocol, 0, 13) . '..';
}
$worker_name = isset($connection->worker) ? $connection->worker->name : $default_worker_name;
if (strlen($worker_name) > 14) {
$worker_name = substr($worker_name, 0, 12) . '..';
}
$str .= str_pad($pid, 9) . str_pad($worker_name, 16) . str_pad($id, 10) . str_pad($transport, 8)
. str_pad($protocol, 16) . str_pad($ipv4, 7) . str_pad($ipv6, 7) . str_pad($recv_q, 13)
. str_pad($send_q, 13) . str_pad($bytes_read, 13) . str_pad($bytes_written, 13) . ' '
. str_pad($state, 14) . ' ' . str_pad($local_address, 22) . ' ' . str_pad($remote_address, 22) ."\n";
}
if ($str) {
file_put_contents(static::$_statisticsFile, $str, FILE_APPEND);
}
}
/**
* 当前进程退出时检查错误。
*
* @return void
*/
public static function checkErrors()
{
if (static::STATUS_SHUTDOWN != static::$_status) {
$error_msg = static::$_OS === OS_TYPE_LINUX ? 'Worker['. posix_getpid() .'] process terminated' : 'Worker process terminated';
$errors = error_get_last();
if ($errors && ($errors['type'] === E_ERROR ||
$errors['type'] === E_PARSE ||
$errors['type'] === E_CORE_ERROR ||
$errors['type'] === E_COMPILE_ERROR ||
$errors['type'] === E_RECOVERABLE_ERROR)
) {
$error_msg .= ' with ERROR: ' . static::getErrorType($errors['type']) . " \"{$errors['message']} in {$errors['file']} on line {$errors['line']}\"";
}
static::log($error_msg);
}
}
/**
* 通过错误代码获取错误消息。
*
* @param integer $type
* @return string
*/
protected static function getErrorType($type)
{
switch ($type) {
case E_ERROR: // 1 //
return 'E_ERROR';
case E_WARNING: // 2 //
return 'E_WARNING';
case E_PARSE: // 4 //
return 'E_PARSE';
case E_NOTICE: // 8 //
return 'E_NOTICE';
case E_CORE_ERROR: // 16 //
return 'E_CORE_ERROR';
case E_CORE_WARNING: // 32 //
return 'E_CORE_WARNING';
case E_COMPILE_ERROR: // 64 //
return 'E_COMPILE_ERROR';
case E_COMPILE_WARNING: // 128 //
return 'E_COMPILE_WARNING';
case E_USER_ERROR: // 256 //
return 'E_USER_ERROR';
case E_USER_WARNING: // 512 //
return 'E_USER_WARNING';
case E_USER_NOTICE: // 1024 //
return 'E_USER_NOTICE';
case E_STRICT: // 2048 //
return 'E_STRICT';
case E_RECOVERABLE_ERROR: // 4096 //
return 'E_RECOVERABLE_ERROR';
case E_DEPRECATED: // 8192 //
return 'E_DEPRECATED';
case E_USER_DEPRECATED: // 16384 //
return 'E_USER_DEPRECATED';
}
return "";
}
/**
* 日志。
*
* @param string $msg
* @return void
*/
public static function log($msg)
{
$msg = $msg . "\n";
if (!static::$daemonize) {
static::safeEcho($msg);
}
file_put_contents((string)static::$logFile, date('Y-m-d H:i:s') . ' ' . 'pid:'
. (static::$_OS === OS_TYPE_LINUX ? posix_getpid() : 1) . ' ' . $msg, FILE_APPEND | LOCK_EX);
}
/**
* 安全输出
* @param $msg
* @param bool $decorated
* @return bool
*/
public static function safeEcho($msg, $decorated = false)
{
$stream = static::outputStream();
if (!$stream) {
return false;
}
if (!$decorated) {
$line = $white = $green = $end = '';
if (static::$_outputDecorated) {
$line = "\033[1A\n\033[K";
$white = "\033[47;30m";
$green = "\033[32;40m";
$end = "\033[0m";
}
$msg = str_replace(array('<n>', '<w>', '<g>'), array($line, $white, $green), $msg);
$msg = str_replace(array('</n>', '</w>', '</g>'), $end, $msg);
} elseif (!static::$_outputDecorated) {
return false;
}
fwrite($stream, $msg);
fflush($stream);
return true;
}
/**
* @param null $stream
* @return bool|resource
*/
private static function outputStream($stream = null)
{
if (!$stream) {
$stream = static::$_outputStream ? static::$_outputStream : STDOUT;
}
if (!$stream || !is_resource($stream) || 'stream' !== get_resource_type($stream)) {
return false;
}
$stat = fstat($stream);
if (($stat['mode'] & 0170000) === 0100000) {
// file
static::$_outputDecorated = false;
} else {
static::$_outputDecorated =
static::$_OS === OS_TYPE_LINUX &&
function_exists('posix_isatty') &&
posix_isatty($stream);
}
return static::$_outputStream = $stream;
}
/**
* Construct.
*
* @param string $socket_name
* @param array $context_option
*/
public function __construct($socket_name = '', $context_option = array())
{
// Save all worker instances.
$this->workerId = spl_object_hash($this);
static::$_workers[$this->workerId] = $this;
static::$_pidMap[$this->workerId] = array();
// Get autoload root path.
$backtrace = debug_backtrace();
$this->_autoloadRootPath = dirname($backtrace[0]['file']);
// Context for socket.
if ($socket_name) {
$this->_socketName = $socket_name;
if (!isset($context_option['socket']['backlog'])) {
$context_option['socket']['backlog'] = static::DEFAULT_BACKLOG;
}
$this->_context = stream_context_create($context_option);
}
}
/**
* 监听
*
* @throws Exception
*/
public function listen()
{
if (!$this->_socketName) {
return;
}
// Autoload.
Autoloader::setRootPath($this->_autoloadRootPath);
if (!$this->_mainSocket) {
// Get the application layer communication protocol and listening address.
list($scheme, $address) = explode(':', $this->_socketName, 2);
// Check application layer protocol class.
if (!isset(static::$_builtinTransports[$scheme])) {
$scheme = ucfirst($scheme);
$this->protocol = substr($scheme,0,1)==='\\' ? $scheme : '\\Protocols\\' . $scheme;
if (!class_exists($this->protocol)) {
$this->protocol = "\\Workerman\\Protocols\\$scheme";
if (!class_exists($this->protocol)) {
throw new Exception("class \\Protocols\\$scheme not exist");
}
}
if (!isset(static::$_builtinTransports[$this->transport])) {
throw new \Exception('Bad worker->transport ' . var_export($this->transport, true));
}
} else {
$this->transport = $scheme;
}
$local_socket = static::$_builtinTransports[$this->transport] . ":" . $address;
// Flag.
$flags = $this->transport === 'udp' ? STREAM_SERVER_BIND : STREAM_SERVER_BIND | STREAM_SERVER_LISTEN;
$errno = 0;
$errmsg = '';
// SO_REUSEPORT.
if ($this->reusePort) {
stream_context_set_option($this->_context, 'socket', 'so_reuseport', 1);
}
// Create an Internet or Unix domain server socket.
$this->_mainSocket = stream_socket_server($local_socket, $errno, $errmsg, $flags, $this->_context);
if (!$this->_mainSocket) {
throw new Exception($errmsg);
}
if ($this->transport === 'ssl') {
stream_socket_enable_crypto($this->_mainSocket, false);
} elseif ($this->transport === 'unix') {
$socketFile = substr($address, 2);
if ($this->user) {
chown($socketFile, $this->user);
}
if ($this->group) {
chgrp($socketFile, $this->group);
}
}
// Try to open keepalive for tcp and disable Nagle algorithm.
if (function_exists('socket_import_stream') && static::$_builtinTransports[$this->transport] === 'tcp') {
set_error_handler(function(){});
$socket = socket_import_stream($this->_mainSocket);
socket_set_option($socket, SOL_SOCKET, SO_KEEPALIVE, 1);
socket_set_option($socket, SOL_TCP, TCP_NODELAY, 1);
restore_error_handler();
}
// Non blocking.
stream_set_blocking($this->_mainSocket, 0);
}
$this->resumeAccept();
}
/**
* 不监听
*
* @return void
*/
public function unlisten() {
$this->pauseAccept();
if ($this->_mainSocket) {
set_error_handler(function(){});
fclose($this->_mainSocket);
restore_error_handler();
$this->_mainSocket = null;
}
}
/**
* 暂停接受新连接。
*
* @return void
*/
public function pauseAccept()
{
if (static::$globalEvent && false === $this->_pauseAccept && $this->_mainSocket) {
static::$globalEvent->del($this->_mainSocket, EventInterface::EV_READ);
$this->_pauseAccept = true;
}
}
/**
* 继续接受新连接。
*
* @return void
*/
public function resumeAccept()
{
// Register a listener to be notified when server socket is ready to read.
if (static::$globalEvent && true === $this->_pauseAccept && $this->_mainSocket) {
if ($this->transport !== 'udp') {
static::$globalEvent->add($this->_mainSocket, EventInterface::EV_READ, array($this, 'acceptConnection'));
} else {
static::$globalEvent->add($this->_mainSocket, EventInterface::EV_READ,
array($this, 'acceptUdpConnection'));
}
$this->_pauseAccept = false;
}
}
/**
* 获取socket名称
*
* @return string
*/
public function getSocketName()
{
return $this->_socketName ? lcfirst($this->_socketName) : 'none';
}
/**
* 运行worker实例
*
* @return void
*/
public function run()
{
//Update process state.
static::$_status = static::STATUS_RUNNING;
// Register shutdown function for checking errors.
register_shutdown_function(array("\\Workerman\\Worker", 'checkErrors'));
// Set autoload root path.
Autoloader::setRootPath($this->_autoloadRootPath);
// Create a global event loop.
if (!static::$globalEvent) {
$event_loop_class = static::getEventLoopName();
static::$globalEvent = new $event_loop_class;
$this->resumeAccept();
}
// Reinstall signal.
static::reinstallSignal();
// Init Timer.
Timer::init(static::$globalEvent);
// Set an empty onMessage callback.
if (empty($this->onMessage)) {
$this->onMessage = function () {};
}
restore_error_handler();
// Try to emit onWorkerStart callback.
if ($this->onWorkerStart) {
try {
call_user_func($this->onWorkerStart, $this);
} catch (\Exception $e) {
static::log($e);
// Avoid rapid infinite loop exit.
sleep(1);
exit(250);
} catch (\Error $e) {
static::log($e);
// Avoid rapid infinite loop exit.
sleep(1);
exit(250);
}
}
// Main loop.
static::$globalEvent->loop();
}
/**
* 停止当前进程实例
*
* @return void
*/
public function stop()
{
// Try to emit onWorkerStop callback.
if ($this->onWorkerStop) {
try {
call_user_func($this->onWorkerStop, $this);
} catch (\Exception $e) {
static::log($e);
exit(250);
} catch (\Error $e) {
static::log($e);
exit(250);
}
}
// Remove listener for server socket.
$this->unlisten();
// Close all connections for the worker.
if (!static::$_gracefulStop) {
foreach ($this->connections as $connection) {
$connection->close();
}
}
// Clear callback.
$this->onMessage = $this->onClose = $this->onError = $this->onBufferDrain = $this->onBufferFull = null;
}
/**
* 接受一个连接
*
* @param resource $socket
* @return void
*/
public function acceptConnection($socket)
{
// Accept a connection on server socket.
set_error_handler(function(){});
$new_socket = stream_socket_accept($socket, 0, $remote_address);
restore_error_handler();
// Thundering herd.
if (!$new_socket) {
return;
}
// TcpConnection.
$connection = new TcpConnection($new_socket, $remote_address);
$this->connections[$connection->id] = $connection;
$connection->worker = $this;
$connection->protocol = $this->protocol;
$connection->transport = $this->transport;
$connection->onMessage = $this->onMessage;
$connection->onClose = $this->onClose;
$connection->onError = $this->onError;
$connection->onBufferDrain = $this->onBufferDrain;
$connection->onBufferFull = $this->onBufferFull;
// Try to emit onConnect callback.
if ($this->onConnect) {
try {
call_user_func($this->onConnect, $connection);
} catch (\Exception $e) {
static::log($e);
exit(250);
} catch (\Error $e) {
static::log($e);
exit(250);
}
}
}
/**
* udp数据包
*
* @param resource $socket
* @return bool
*/
public function acceptUdpConnection($socket)
{
set_error_handler(function(){});
$recv_buffer = stream_socket_recvfrom($socket, static::MAX_UDP_PACKAGE_SIZE, 0, $remote_address);
restore_error_handler();
if (false === $recv_buffer || empty($remote_address)) {
return false;
}
// UdpConnection.
$connection = new UdpConnection($socket, $remote_address);
$connection->protocol = $this->protocol;
if ($this->onMessage) {
try {
if ($this->protocol !== null) {
/** @var \Workerman\Protocols\ProtocolInterface $parser */
$parser = $this->protocol;
$recv_buffer = $parser::decode($recv_buffer, $connection);
// Discard bad packets.
if ($recv_buffer === false)
return true;
}
ConnectionInterface::$statistics['total_request']++;
call_user_func($this->onMessage, $connection, $recv_buffer);
} catch (\Exception $e) {
static::log($e);
exit(250);
} catch (\Error $e) {
static::log($e);
exit(250);
}
}
return true;
}
}
