public function __construct()
{
$this->base = event_base_new();
$this->callback = $this->createLibeventCallback();
$this->timersGc = new \SplQueue();
$this->timersGc->setIteratorMode(\SplQueue::IT_MODE_DELETE);
}
public function __construct()
{
// @codeCoverageIgnoreStart
if (!\extension_loaded("libevent")) {
throw new \RuntimeException("The pecl libevent extension is required to use " . __CLASS__);
}
// @codeCoverageIgnoreEnd
$this->base = \event_base_new();
$this->keepAliveBase = \event_base_new();
/**
* Prior to PHP7 we can't cancel closure watchers inside their own callbacks
* because PHP will fatal. In legacy versions we schedule manual GC workarounds.
*
* @link https://bugs.php.net/bug.php?id=62452
*/
if (PHP_MAJOR_VERSION < 7) {
$this->gcEvent = event_new();
\event_timer_set($this->gcEvent, function () {
$this->garbage = [];
$this->isGcScheduled = false;
\event_del($this->gcEvent);
});
\event_base_set($this->gcEvent, $this->keepAliveBase);
}
$this->onCoroutineResolution = function ($e = null, $r = null) {
if ($e) {
$this->onCallbackError($e);
}
};
}
/**
* Construct new event base
*
* @see event_base_new
* @link http://www.php.net/manual/function.event-base-new.php
* @param int $priority
* @throws EventException
*/
public function __construct($priority = self::DEFAULT_PRIORITY)
{
if (false === ($this->resource = event_base_new())) {
throw $this->exception('Could not create event base resourse (event_base_new).');
}
$this->setPriority($priority);
}
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();
}
/**
* Creates the main event loop
*
* @param int $priorities The number of different priorities
*/
public function __construct($priorities = null)
{
$this->resource = event_base_new();
if (!is_null($priorities)) {
event_base_priority_init($this->resource, $priorities);
}
}
public static function getBase()
{
if (!self::$globalBase) {
self::$globalBase = event_base_new();
}
return self::$globalBase;
}
public function __construct($addr = '127.0.0.1', $port = 8305, $listenQueue = 512)
{
if (is_null(self::$_logger)) {
self::$_logger = \Zopt\Base\Logger::getLogger(__CLASS__);
}
if (!extension_loaded('libevent')) {
self::$_logger->crit('FATAL: Please firstly install libevent extension.');
die;
}
$this->_addr = $addr;
$this->_port = $port;
$this->_listenQueue = $listenQueue;
$this->_started = FALSE;
$this->_sock = NULL;
// Init the event machine using libevent c extension
$this->_listenEvent = NULL;
$this->_eventBase = event_base_new();
$this->_streams = array();
// Register signal handlers
$this->_signalEvents = array();
foreach (array(SIGTERM, SIGHUP, SIGINT, SIGQUIT) as $signo) {
$event = event_new();
event_set($event, $signo, EV_SIGNAL | EV_PERSIST, array($this, 'handleSignalEvent'), $signo);
event_base_set($event, $this->_eventBase);
event_add($event);
$this->_signalEvents[$signo] = $event;
}
}
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->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);
}
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);
}
/**
* LeBase constructor.
*/
public function __construct()
{
$this->handle = event_base_new();
if ($this->handle === false) {
throw new \RuntimeException('Can not initialize libevent.');
}
}
/**
* Normally this would go into the __construct() function but it's split out into its own
* method because we also have to initialize() when calling afterFork().
*/
private function initialize()
{
$this->base = event_base_new();
$this->gcEvent = event_new();
event_timer_set($this->gcEvent, [$this, 'collectGarbage']);
event_base_set($this->gcEvent, $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);
}
public function __construct()
{
$this->eventBase = event_base_new();
$this->nextTickQueue = new NextTickQueue($this);
$this->timerEvents = new SplObjectStorage();
$this->createTimerCallback();
$this->createStreamCallback();
}
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]);
}
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 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);
}
/**
* 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_);
}
public function __construct($address, $port)
{
$this->base = event_base_new();
$this->event = event_new();
Logger::getInstance()->outString("Create new socket for " . $address . ":" . $port);
$errno = 0;
$errstr = '';
$socket = stream_socket_server('tcp://' . $address . ':' . $port, $errno, $errstr);
stream_set_blocking($socket, 0);
event_set($this->event, $socket, EV_READ | EV_PERSIST, array($this, 'accept'), $this->base);
event_base_set($this->event, $this->base);
event_add($this->event);
$this->onLoad();
}
public function __construct(RedisJobQueue $parent, $prefix, $file, $limit = 4)
{
$this->parent = $parent;
$this->prefix = $prefix;
$this->limit = $limit;
$script = realpath($file);
if (!$script) {
$script = realpath(dirname(realpath(CONFIG_FILE)) . '/' . $file);
}
$this->script = $script ? $script : $file;
if (!function_exists('event_base_new')) {
$this->log('Warning : You should install libevent as a PHP module');
} else {
$this->events = event_base_new();
}
}
/**
* @param bool $enableSignals True to enable signal handling, false to disable.
* @param \Icicle\Loop\Events\EventFactoryInterface|null $eventFactory
* @param resource|null Resource created by event_base_new() or null to automatically create an event base.
*
* @throws \Icicle\Loop\Exception\UnsupportedError If the libevent extension is not loaded.
*/
public function __construct($enableSignals = true, EventFactoryInterface $eventFactory = null, $base = null)
{
// @codeCoverageIgnoreStart
if (!self::enabled()) {
throw new UnsupportedError(__CLASS__ . ' requires the libevent extension.');
}
// @codeCoverageIgnoreEnd
// @codeCoverageIgnoreStart
if (!is_resource($base)) {
$this->base = event_base_new();
} else {
// @codeCoverageIgnoreEnd
$this->base = $base;
}
parent::__construct($enableSignals, $eventFactory);
}
public function __construct()
{
echo 'USING LIBEVENTLOOP' . PHP_EOL;
$this->eventBase = event_base_new();
$this->nextTickQueue = new NextTickQueue($this);
$this->futureTickQueue = new FutureTickQueue($this);
$this->timerEvents = new SplObjectStorage();
$this->createTimerCallback();
$this->createStreamCallback();
$this->addTimer($this->nextPoll, function () {
$this->socketTick();
});
$this->addPeriodicTimer(5, function () {
//KUBE::Log([count($this->readSockets).":".count($this->readSocketListeners),count($this->writeSockets).":".count($this->writeSocketListeners)],'sockets');
$this->adjustNextPoll();
gc_collect_cycles();
});
}
public function __construct($host = '127.0.0.1', $port = 80)
{
ini_set('precision', 50);
$this->host = $host;
$this->port = $port;
$this->clientCount = 0;
$this->connections = array();
$this->buffers = array();
$this->unauthorised = array();
$this->pool = array();
$this->i = 0;
$this->buffer_id = 0;
$this->event = new Event();
if (function_exists('event_base_new')) {
$this->ev_base = event_base_new();
} else {
trigger_error("Libevent does not seem to be installed properly on your system/php.See README for more info\n", E_USER_ERROR);
}
$this->fds = [];
}
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();
}
}
<?php
$base_fd = event_base_new();
$times = 0;
$limit = 10;
$index = array();
function httpGet($host, $base_fd)
{
global $index;
$fd = stream_socket_client("{$host}", $errno, $errstr, 3, STREAM_CLIENT_ASYNC_CONNECT | STREAM_CLIENT_CONNECT);
$index[$fd] = 0;
$event_fd = event_new();
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]);
}
}
function init()
{
$this->base_event = event_base_new();
$this->server_event = event_new();
}
/**
* 构造函数
* @return void
*/
public function __construct()
{
$this->_eventBase = event_base_new();
}
