public function start()
{
$this->onStart();
$this->base = event_base_new();
if ($this->_server) {
$this->event = event_new();
event_set($this->event, $this->_server, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
}
if ($this->_service) {
$this->service_event = event_new();
event_set($this->service_event, $this->_service, EV_READ | EV_PERSIST, array($this, 'service'), $this->base);
event_base_set($this->service_event, $this->base);
event_add($this->service_event);
}
if ($this->_master) {
$this->master_event = event_new();
event_set($this->master_event, $this->_master, EV_READ | EV_PERSIST | EV_WRITE, array($this, 'master'), $this->base);
event_base_set($this->master_event, $this->base);
event_add($this->master_event);
}
if ($this->timer) {
$timer = event_timer_new();
event_timer_set($timer, array($this, '_onTimer'), $timer);
event_base_set($timer, $this->base);
//event_timer_pending($timer, $this->timer * 1000000);
event_timer_add($timer, $this->timer * 1000000);
}
event_base_loop($this->base);
}
function EpollSocketServer($port)
{
global $errno, $errstr;
if (!extension_loaded('libevent')) {
die("Please install libevent extension firstly/n");
}
if ($port < 1024) {
die("Port must be a number which bigger than 1024/n");
}
$socket_server = stream_socket_server("tcp://0.0.0.0:{$port}", $errno, $errstr);
if (!$socket_server) {
die("{$errstr} ({$errno})");
}
stream_set_blocking($socket_server, 0);
// 非阻塞
$base = event_base_new();
$event = event_new();
event_set($event, $socket_server, EV_READ | EV_PERSIST, array(__CLASS__, 'ev_accept'), $base);
event_base_set($event, $base);
event_add($event);
event_base_loop($base);
self::$connections = array();
self::$buffers = array();
self::$imei = array();
}
public function __construct($port)
{
global $errno, $errstr;
if (!extension_loaded('libevent')) {
die("Please install libevent extension firstly\n");
}
if ($port < 1024) {
die("Port must be a number which bigger than 1024\n");
}
$socket_server = stream_socket_server("tcp://0.0.0.0:{$port}", $errno, $errstr);
if (!$socket_server) {
die("{$errstr} ({$errno})");
}
stream_set_blocking($socket_server, 0);
// 非阻塞
// event_base_new — Create and initialize new event base
$base = event_base_new();
// event_new — Create new event
$event = event_new();
// event_set — Prepare an event
event_set($event, $socket_server, EV_READ | EV_PERSIST, [__CLASS__, 'ev_accept'], $base);
// event_base_set — Associate event base with an event
event_base_set($event, $base);
// event_add — Add an event to the set of monitored events
event_add($event);
// event_base_loop — Handle events
event_base_loop($base);
self::$connections = [];
self::$buffers = [];
}
public function start()
{
$this->base = event_base_new();
if ($this->_server) {
$this->event = event_new();
event_set($this->event, $this->_server, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
}
foreach ($this->_services as $serviceId => $service) {
$event = event_new();
event_set($event, $service, EV_READ | EV_PERSIST | EV_WRITE, array($this, 'service'), $this->base);
event_base_set($event, $this->base);
event_add($event);
$this->events[$serviceId] = $event;
}
if ($this->timer) {
$timer = event_timer_new();
event_timer_set($timer, array($this, '_onTimer'), $timer);
event_base_set($timer, $this->base);
//event_timer_pending($timer, $this->timer * 1000000);
event_timer_add($timer, $this->timer * 1000000);
}
event_base_loop($this->base);
}
/**
* Runtime of Master process
* @return void
*/
public function run()
{
Daemon::$process = $this;
$this->prepareSystemEnv();
class_exists('Timer');
// ensure loading this class
gc_enable();
$this->eventBase = event_base_new();
$this->registerEventSignals();
FS::initEvent();
$this->fileWatcher = new FileWatcher();
$this->workers = new ThreadCollection();
$this->collections['workers'] = $this->workers;
Daemon::$appResolver = (require Daemon::$config->path->value);
$this->IPCManager = Daemon::$appResolver->getInstanceByAppName('IPCManager');
Daemon::$appResolver->preload(true);
$this->callbacks = new SplStack();
$this->spawnWorkers(min(Daemon::$config->startworkers->value, Daemon::$config->maxworkers->value));
Timer::add(function ($event) use(&$cbs) {
$self = Daemon::$process;
static $c = 0;
++$c;
if ($c > 0xfffff) {
$c = 1;
}
if ($c % 10 == 0) {
$self->workers->removeTerminated(true);
gc_collect_cycles();
} else {
$self->workers->removeTerminated();
}
if (isset(Daemon::$config->mpm->value) && is_callable(Daemon::$config->mpm->value)) {
call_user_func(Daemon::$config->mpm->value);
} else {
// default MPM
$state = Daemon::getStateOfWorkers($self);
if ($state) {
$n = max(min(Daemon::$config->minspareworkers->value - $state['idle'], Daemon::$config->maxworkers->value - $state['alive']), Daemon::$config->minworkers->value - $state['alive']);
if ($n > 0) {
Daemon::log('Spawning ' . $n . ' worker(s).');
$self->spawnWorkers($n);
event_base_loopbreak($self->eventBase);
}
$n = min($state['idle'] - Daemon::$config->maxspareworkers->value, $state['alive'] - Daemon::$config->minworkers->value);
if ($n > 0) {
Daemon::log('Stopping ' . $n . ' worker(s).');
$self->stopWorkers($n);
}
}
}
$event->timeout();
}, 1000000.0 * Daemon::$config->mpmdelay->value, 'MPM');
while (!$this->breakMainLoop) {
while (!$this->callbacks->isEmpty()) {
call_user_func($this->callbacks->shift(), $this);
}
event_base_loop($this->eventBase);
}
}
public function loop()
{
if (!($this->event_base = event_base_new())) {
throw new RuntimeException("Can't create event base");
}
$this->addSocketEvent();
event_base_loop($this->event_base);
}
/**
* {@inheritdoc}
*/
protected function dispatch(bool $blocking)
{
$flags = EVLOOP_ONCE;
if (!$blocking) {
$flags |= EVLOOP_NONBLOCK;
}
event_base_loop($this->base, $flags);
// Dispatch I/O, timer, and signal callbacks.
}
public function loop()
{
if (!($this->event_base = event_base_new())) {
throw new RuntimeException("Can't create event base");
}
foreach ($this->addrs as $addr) {
$this->addAddr($addr);
}
event_base_loop($this->event_base);
}
public function worker_callback(swoole_process $worker)
{
self::$worker_event_base[$worker->pipe] = event_base_new();
$event = event_new();
//$GLOBALS['worker'] = $worker;
event_set($event, $worker->pipe, EV_READ | EV_PERSIST, array($this, 'worker_accept'), $worker);
event_base_set($event, self::$worker_event_base[$worker->pipe]);
event_add($event);
event_base_loop(self::$worker_event_base[$worker->pipe]);
}
private function doRun($flags = 0)
{
$this->isRunning = TRUE;
event_base_loop($this->base, $flags);
$this->isRunning = FALSE;
if ($this->stopException) {
$e = $this->stopException;
throw $e;
}
}
public static function setInterval($fn, $interval)
{
$e = new Timer($fn, $interval);
self::$items->attach($e);
return $e;
}
/**
* Clear the specified interval
*/
public static function clearInterval(Timer $timer)
{
self::$items->detach($timer);
public function listen()
{
echo "Start listening port " . $this->opts['port'] . "\n";
$socket = stream_socket_server('tcp://0.0.0.0:' . $this->opts['port'], $errno, $errstr);
stream_set_blocking($socket, 0);
$this->base = event_base_new();
$listenerEvent = event_new();
event_set($listenerEvent, $socket, EV_READ | EV_PERSIST, array($this, 'onAccept'), null);
event_base_set($listenerEvent, $this->base);
event_add($listenerEvent, -1);
event_base_loop($this->base);
}
public function run()
{
$this->init();
//建立服务器端Socket
$this->server_sock = $this->create("tcp://{$this->config['host']}:{$this->config['port']}");
//设置事件监听，监听到服务器端socket可读，则有连接请求
\event_set($this->server_event, $this->server_sock, EV_READ | EV_PERSIST, __CLASS__ . '::server_handle_connect', $this);
\event_base_set($this->server_event, $this->base_event);
\event_add($this->server_event);
$this->client->onStart();
\event_base_loop($this->base_event);
}
/**
* Start listening
*/
public function listen()
{
$this->handle_ = stream_socket_server("tcp://{$this->host_}:{$this->port_}", $this->errno_, $this->errstr_);
stream_set_blocking($this->handle_, 0);
// no blocking
$this->base_ = \event_base_new();
$this->serverEvent_ = \event_new();
\event_set($this->serverEvent_, $this->handle_, EV_READ | EV_PERSIST, array($this, 'onConnect'));
\event_base_set($this->serverEvent_, $this->base_);
\event_add($this->serverEvent_);
\event_base_loop($this->base_);
}
/**
* 运行服务器程序
* @return unknown_type
*/
function run($setting)
{
$this->init();
//建立服务器端Socket
$this->server_sock = $this->create("tcp://{$this->host}:{$this->port}");
//设置事件监听，监听到服务器端socket可读，则有连接请求
event_set($this->server_event, $this->server_sock, EV_READ | EV_PERSIST, array($this, "event_connect"));
event_base_set($this->server_event, $this->base_event);
event_add($this->server_event);
$this->spawn($setting);
$this->protocol->onStart($this);
event_base_loop($this->base_event);
}
/**
* 运行服务器程序
* @return unknown_type
*/
function run()
{
//初始化事件系统
$this->init();
//建立服务器端Socket
$this->server_sock = $this->create("udp://{$this->host}:{$this->port}");
//设置事件监听，监听到服务器端socket可读，则有连接请求
event_set($this->server_event, $this->server_sock, EV_READ | EV_PERSIST, "sw_server_handle_recvfrom", $this);
event_base_set($this->server_event, $this->base_event);
event_add($this->server_event);
$this->protocol->onStart();
event_base_loop($this->base_event);
}
public function listen()
{
if (!$this->client_type) {
throw new \Exception('Client type was not defined, please call setClientType() with the type of client (ie \\Beehive\\Clients\\Telnet) before listen()');
}
if (!is_callable($this->read_callback)) {
throw new \Exception('Read callback is not defined with a valid callback, please call setReadCallback() with a valid callback');
}
$this->connection = stream_socket_server('tcp://' . $this->host . ':' . $this->port, $errno, $errstr);
stream_set_blocking($this->connection, 0);
$event = event_new();
event_set($event, $this->connection, EV_READ | EV_PERSIST, [$this, 'addClient'], $this->event_base);
event_base_set($event, $this->event_base);
event_add($event);
event_base_loop($this->event_base);
}
/**
* 运行服务器程序
* @return unknown_type
*/
function run($num = 1)
{
//初始化事件系统
if (!$this->protocol instanceof Swoole_TCP_Server_Protocol) {
return error(902);
}
$this->init();
//建立服务器端Socket
$this->server_sock = $this->create("tcp://{$this->host}:{$this->port}");
//设置事件监听，监听到服务器端socket可读，则有连接请求
event_set($this->server_event, $this->server_sock, EV_READ | EV_PERSIST, "sw_server_handle_connect", $this);
event_base_set($this->server_event, $this->base_event);
event_add($this->server_event);
if ($num - 1 > 0) {
sw_spawn($num - 1);
}
$this->protocol->onStart();
event_base_loop($this->base_event);
}
public function libevent_serverAction()
{
function print_line($fd, $events, $arg)
{
echo "callback fired" . PHP_EOL;
var_dump($arg[0]->recv());
$arg[0]->send("got msg " . ZmqController::$msgs);
if (ZmqController::$msgs++ >= 10) {
event_base_loopexit($arg[1]);
}
}
$base = event_base_new();
$event = event_new();
$context = new ZMQContext();
$rep = $context->getSocket(ZMQ::SOCKET_REP);
$rep->bind("tcp://127.0.0.1:5555");
$fd = $rep->getSockOpt(ZMQ::SOCKOPT_FD);
event_set($event, $fd, EV_READ | EV_PERSIST, "print_line", array($rep, $base));
event_base_set($event, $base);
event_add($event);
event_base_loop($base);
}
function EpollSocketServer($port)
{
if (!extension_loaded('libevent')) {
self::$errstr = "请先安装libevent扩展库。";
return;
}
if ($port < 1024) {
self::$errstr = "端口号不应小于1024";
return;
}
set_time_limit(0);
$socket_server = stream_socket_server("tcp://0.0.0.0:{$port}", self::$errno, self::$errstr);
stream_set_blocking($socket_server, 0);
// 非阻塞
$base = event_base_new();
$event = event_new();
event_set($event, $socket_server, EV_READ | EV_PERSIST, array(__CLASS__, 'ev_accept'), $base);
event_base_set($event, $base);
event_add($event);
event_base_loop($base);
self::$connections = array();
self::$buffers = array();
}
public static function init()
{
Daemon::$eventBase = event_base_new();
$args = $_SERVER['argv'];
if (!isset($args[1]) || !isset($args[2])) {
Terminal::drawStr('usage: php xxx.php sArea (start|stop|restart|reload|status)' . "\n");
exit(-1);
}
// todo run multi app in one daemon.
$sArea = $args[1];
$command = $args[2];
$appName = Config::get('socket_server_class', null, true);
Daemon::$runName = $appName;
$runAppInstance = array($appName => $appName);
if ($command == 'start') {
// fork later
self::$pid = posix_getpid();
Debug::log('start');
foreach ($runAppInstance as $appName) {
$obj = new $appName();
}
while (!Daemon::$breakEventLoop) {
event_base_loop(daemon::$eventBase, EVLOOP_ONCE);
// 清空本次写状态数组
gc_collect_cycles();
//daemon::debug('<== evet_base_loop() ending');
}
} elseif ($command == 'stop') {
// cat pid, stop
} elseif ($command == 'status') {
// cat pid, show status
} elseif ($command == 'restart') {
//self::stop();
//self::start();
}
}
/**
* {@inheritdoc}
*/
public function run()
{
$this->running = true;
while ($this->running) {
$this->nextTickQueue->tick();
$this->futureTickQueue->tick();
$flags = EVLOOP_ONCE;
if (!$this->running || !$this->nextTickQueue->isEmpty() || !$this->futureTickQueue->isEmpty()) {
$flags |= EVLOOP_NONBLOCK;
} elseif (!$this->streamEvents && !$this->timerEvents->count()) {
break;
}
event_base_loop($this->eventBase, $flags);
}
}
/**
* 事件循环
* @see EventInterface::loop()
*/
public function loop()
{
event_base_loop($this->_eventBase);
}
public function run()
{
// @codeCoverageIgnoreStart
event_base_loop($this->base);
// @codeCoverageIgnoreEnd
}
<?php
function print_line($fd, $events, $arg)
{
static $max_requests = 0;
$max_requests++;
if ($max_requests == 10) {
// exit loop after 10 writes
event_base_loopexit($arg[1]);
}
// print the line
echo fgets($fd);
}
// create base and event
$base = event_base_new();
$event = event_new();
$fd = STDIN;
// set event flags
event_set($event, $fd, EV_READ | EV_PERSIST, "print_line", array($event, $base));
// set event base
event_base_set($event, $base);
// enable event
event_add($event);
// start event loop
event_base_loop($base);
public function shutdown($hard = FALSE)
{
if (Daemon::$settings['logevents']) {
Daemon::log('[WORKER ' . $this->pid . '] event shutdown(' . ($hard ? 'HARD' : '') . ') invoked.');
}
if (Daemon::$settings['throwexceptiononshutdown']) {
throw new Exception('event shutdown');
}
@ob_flush();
if ($this->terminated === TRUE) {
if ($hard) {
exit(0);
}
return;
}
$this->terminated = TRUE;
$this->closeSockets();
$this->setStatus(3);
if ($hard) {
exit(0);
}
$reloadReady = $this->appInstancesReloadReady();
foreach ($this->queue as $r) {
if ($r instanceof stdClass) {
continue;
}
if ($r->running) {
$r->finish(-2);
}
}
$n = 0;
while ($this->queueWait && sizeof($this->queue) > 0 || !$reloadReady) {
if ($n++ === 100) {
$reloadReady = $this->appInstancesReloadReady();
$n = 0;
}
pcntl_signal_dispatch();
event_add($this->timeoutEvent, $this->microsleep);
event_base_loop($this->eventBase, EVLOOP_ONCE);
$this->readPool();
$this->runQueue();
}
posix_kill(posix_getppid(), SIGCHLD);
exit(0);
}
/**
* Starts the event loop.
*
* THe NONBLOCK option will loop through the event once and exit
* immediately after there are no outstanding events.
*
* The ONCE does the same, but requires at least one event to be handled.
*
* @return void
*/
public function loop($flags = 0)
{
event_base_loop($this->eventBase, $flags);
}
public function run()
{
event_base_loop($this->ev_base);
}
event_set($event_fd, $fd, EV_WRITE | EV_PERSIST, function ($fd, $events, $arg) use($host) {
global $times, $limit, $index;
if (!$index[$fd]) {
$index[$fd] = 1;
$out = "GET / HTTP/1.1\r\n";
$out .= "Host: {$host}\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fd, $out);
} else {
$str = fread($fd, 4096);
echo $str, PHP_EOL;
if (feof($fd)) {
fclose($fd);
$times++;
echo "done\n";
if ($times == $limit - 1) {
event_base_loopexit($arg[1]);
}
}
}
}, array($event_fd, $base_fd));
event_base_set($event_fd, $base_fd);
event_add($event_fd);
}
for ($i = 0; $i < $limit; $i++) {
echo "{$i}\n";
httpGet($argv[1], $base_fd);
//echo file_get_contents("http://$argv[1]");
}
event_base_loop($base_fd);
function loop()
{
event_base_loop($this->handle);
return $this;
}
