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 getProcess()
{
if (!$this->process) {
$descriptorspec = array(0 => array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("pipe", "w"));
$cmd = PHPBIN . ' -f ' . realpath(__DIR__ . '/../bin/') . '/worker.php';
$this->process = proc_open($cmd, $descriptorspec, $pipes, '/tmp', array('prefix' => $this->parent->prefix, 'bootstrap' => $this->parent->script, 'verbose' => VERBOSE));
if ($this->process === false) {
$error = error_get_last();
$this->parent->log('Error : unable to start a process - ' . $error['message']);
} else {
$this->std_out = $pipes[0];
$this->std_in = $pipes[1];
$this->std_err = $pipes[2];
stream_set_blocking($this->std_in, 0);
stream_set_blocking($this->std_err, 0);
VERBOSE && $this->parent->log('Start a new process : ' . $this->process);
if (function_exists('event_new')) {
$this->event = event_new();
event_set($this->event, $this->std_in, EV_READ | EV_PERSIST, array($this, 'onRead'), array($this->event, $this->parent->events));
event_base_set($this->event, $this->parent->events);
event_add($this->event);
}
}
}
return $this->process;
}
public function request($method = null)
{
if (!$this->uri instanceof Zend_Uri_Http) {
/** @see Zend_Http_Client_Exception */
require_once 'Zend/Http/Client/Exception.php';
throw new Zend_Http_Client_Exception('No valid URI has been passed to the client');
}
if ($method) {
error_log('aaa');
$this->setMethod($method);
}
$uri = $this->uri;
$port = isset($tmp['port']) ? $tmp['port'] : 80;
$host = $uri->getHost();
$port = $uri->getPort();
$socket = stream_socket_client("{$host}:{$port}", $errno, $errstr, (int) $this->config['timeout'], STREAM_CLIENT_ASYNC_CONNECT | STREAM_CLIENT_CONNECT);
stream_set_blocking($socket, 0);
$base = $this->config['eventbase'];
$writeEvent = event_new();
event_set($writeEvent, $socket, EV_WRITE, array($this, 'onAccept'), array($writeEvent, $base));
event_base_set($writeEvent, $base);
event_add($writeEvent);
$readEvent = event_new();
event_set($readEvent, $socket, EV_READ | EV_PERSIST, array($this, 'onRead'), array($readEvent, $base));
event_base_set($readEvent, $base);
event_add($readEvent);
if (!empty($callback)) {
$this->callback = $callback;
}
}
/**
* {@inheritdoc}
*/
protected function createEvent($base, SocketEventInterface $socket, callable $callback)
{
$event = event_new();
event_set($event, $socket->getResource(), EV_WRITE, $callback, $socket);
event_base_set($event, $base);
return $event;
}
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 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);
}
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 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]);
}
}
}
}, array($event_fd, $base_fd));
event_base_set($event_fd, $base_fd);
event_add($event_fd);
}
public function start()
{
self::$_logger->info('Server starts.');
// Init a non-blocking TCP socket for listening
$this->_sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if (!$this->_sock) {
$errno = socket_last_error();
$errstr = socket_strerror($errno);
self::$_logger->err("Socket create error: {$errstr} ({$errno})");
die;
}
socket_set_nonblock($this->_sock);
if (!socket_bind($this->_sock, $this->_addr, $this->_port)) {
$errno = socket_last_error();
$errstr = socket_strerror($errno);
self::$_logger->err("Socket bind error: {$errstr} ({$errno})");
die;
}
if (!socket_listen($this->_sock, $this->_listenQueue)) {
$errno = socket_last_error();
$errstr = socket_strerror($errno);
self::$_logger->err("Socket listen error: {$errstr} ({$errno})");
die;
}
// For the listening socket, we use raw event to handle it.
$this->_listenEvent = event_new();
event_set($this->_listenEvent, $this->_sock, EV_READ | EV_PERSIST, array($this, 'handleAcceptEvent'));
event_base_set($this->_listenEvent, $this->_eventBase);
event_add($this->_listenEvent);
// Endless loop
$this->_started = TRUE;
event_base_loop($this->_eventBase);
// The loop ends here.
$this->stop();
}
}
/**
* Creates a bufferized stream
* @return Buffer
*/
public static function buffer($stream)
{
if (is_string($stream)) {
public function connectTo($host, $port, $blockConnect = false)
{
Debug::netEvent(get_class($this) . '::' . __METHOD__ . '(' . $host . ':' . $port . ') invoked.');
$connSocket = stream_socket_client("tcp://{$host}:{$port}", $errno, $errstr, 30);
//add err connect
stream_set_blocking($connSocket, 0);
if (!is_resource($connSocket)) {
Debug::netErrorEvent(get_class($this) . ': can not add errorneus socket with address \'' . $host . ':' . $port . '\'.');
return false;
}
$connId = daemon::getNextSocketId();
//@todo 增加阻塞 connect ， 这样可以返回 connId 的时候 socketSession 已经建立好
if ($blockConnect) {
}
$ev = event_new();
// why not use EV_PERSIST, is because first event is acceptEvent?
if (!event_set($ev, $connSocket, EV_WRITE, array($this, 'onConnectedEvent'), array($connId))) {
Debug::netErrorEvent(get_class($this) . '::' . __METHOD__ . ': can not set onAcceptEvent() on binded socket: ' . Debug::dump($connSocket));
return false;
}
event_base_set($ev, daemon::$eventBase);
event_add($ev, 1 * 1000 * 1000);
$this->checkConnSocketPool[$connId] = $connSocket;
$this->checkConnEvPool[$connId] = $ev;
return $connId;
}
public function onAccept($listener, $what, $arg)
{
$socket = stream_socket_accept($listener, 5000);
if (!$socket) {
echo "Invalid fd\n";
return;
}
echo "Accept new socket ({$socket})\n";
// echo "Peer name=" . $this->peername($socket) . "\n";
// echo "Sock name=" . $this->sockname($socket) . "\n";
stream_set_blocking($socket, 0);
// stream_set_timeout($socket, 5000);
$readEvent = event_new();
$writeEvent = event_new();
if (!$readEvent || !$writeEvent) {
echo "Unable to create read or write event ({$socket})\n";
$this->close($socket);
}
event_set($readEvent, $socket, EV_READ | EV_PERSIST, array($this, 'onRead'), null);
event_set($writeEvent, $socket, EV_WRITE | EV_PERSIST, array($this, 'onWrite'), null);
event_base_set($readEvent, $this->base);
event_base_set($writeEvent, $this->base);
$this->sockets[(int) $socket] = ['readEvent' => $readEvent, 'writeEvent' => $writeEvent];
event_add($readEvent, -1);
}
public function addWriteStream($stream, $listener)
{
$event = event_new();
event_set($event, $stream, EV_READ | EV_PERSIST, $listener);
event_base_set($event, $this->base);
event_add($event);
$this->events[(int) $stream] = $event;
}
/**
* Add signal handler.
*
* @param $signal
* @param $callback
* @return bool
*/
public function addSignal($signal, $callback)
{
$event = event_new();
$this->_signalEvents[$signal] = $event;
event_set($event, $signal, EV_SIGNAL | EV_PERSIST, $callback);
event_base_set($event, $this->_eventBase);
event_add($event);
}
public function onConnect()
{
$clientSocket = stream_socket_accept($this->handle_);
stream_set_blocking($clientSocket, 0);
$clientEvent = event_new();
\event_set($clientEvent, $clientSocket, EV_READ | EV_PERSIST, array($this, 'onRequest'), array($clientEvent));
\event_base_set($clientEvent, $this->base_);
event_add($clientEvent);
}
function accept_cb($socket, $flag, $base)
{
$conn = stream_socket_accept($socket, 0);
stream_set_blocking($conn, 0);
$event = event_new();
event_set($event, $conn, EV_READ | EV_PERSIST, read_cb, $base);
event_base_set($event, $base);
event_add($event);
}
public function setTimeout($callback, $interval_ms)
{
$base = \Event\Emitter::getBase();
$event = event_timer_new();
$arg = array($callback, $event, $interval_ms);
event_timer_set($event, array($this, 'ev_timer'), $arg);
event_base_set($event, $base);
event_add($event, $interval_ms * 1000);
}
/**
* {@inheritdoc}
*/
public function start(Timer $timer)
{
if (!isset($this->timers[$timer])) {
$event = event_new();
event_timer_set($event, $this->callback, $timer);
event_base_set($event, $this->base);
$this->timers[$timer] = $event;
event_add($event, $timer->getInterval() * self::MICROSEC_PER_SEC);
}
}
function add($event)
{
$ev = event_new();
event_set($ev, $event->fd, $event->events, function () use($event) {
call_user_func($event->callback, $event);
});
event_base_set($ev, $this->handle);
event_add($ev);
$event->base = $this;
$event->handle = $ev;
return $this;
}
/**
* 运行服务器程序
* @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);
}
/**
* @param \Icicle\Loop\LoopInterface $loop
* @param \Icicle\Loop\Events\EventFactoryInterface $factory
* @param resource $base
*/
public function __construct(LibeventLoop $loop, EventFactoryInterface $factory)
{
parent::__construct($loop, $factory);
$callback = $this->createSignalCallback();
$base = $loop->getEventBase();
foreach ($this->getSignalList() as $signo) {
$event = event_new();
event_set($event, $signo, EV_SIGNAL | EV_PERSIST, $callback);
event_base_set($event, $base);
event_add($event);
$this->events[$signo] = $event;
}
}
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();
}
/**
* 添加事件
* @see EventInterface::add()
*/
public function add($fd, $flag, $func, $args = null)
{
switch ($flag) {
case self::EV_SIGNAL:
$fd_key = (int) $fd;
$real_flag = EV_SIGNAL | EV_PERSIST;
$this->_eventSignal[$fd_key] = event_new();
if (!event_set($this->_eventSignal[$fd_key], $fd, $real_flag, $func, null)) {
return false;
}
if (!event_base_set($this->_eventSignal[$fd_key], $this->_eventBase)) {
return false;
}
if (!event_add($this->_eventSignal[$fd_key])) {
return false;
}
return true;
case self::EV_TIMER:
case self::EV_TIMER_ONCE:
$event = event_new();
$timer_id = (int) $event;
if (!event_set($event, 0, EV_TIMEOUT, array($this, 'timerCallback'), $timer_id)) {
return false;
}
if (!event_base_set($event, $this->_eventBase)) {
return false;
}
$time_interval = $fd * 1000000;
if (!event_add($event, $time_interval)) {
return false;
}
$this->_eventTimer[$timer_id] = array($func, (array) $args, $event, $flag, $time_interval);
return $timer_id;
default:
$fd_key = (int) $fd;
$real_flag = $flag == self::EV_READ ? EV_READ | EV_PERSIST : EV_WRITE | EV_PERSIST;
$event = event_new();
if (!event_set($event, $fd, $real_flag, $func, null)) {
return false;
}
if (!event_base_set($event, $this->_eventBase)) {
return false;
}
if (!event_add($event)) {
return false;
}
$this->_allEvents[$fd_key][$flag] = $event;
return true;
}
}
private function __construct($name, $cb)
{
if (!is_callable($cb)) {
return false;
}
if ($name == '') {
$name = 'tEv_' . Daemon::getNextTimerEventId();
}
$this->name = $name;
$this->cb = $cb;
$this->ev = event_new();
event_set($this->ev, STDIN, EV_TIMEOUT, array(__CLASS__, 'eventCall'), array($name));
event_base_set($this->ev, Daemon::$eventBase);
Daemon::$timerEventPool[$name] = $this;
}
/**
* Register signals.
* @return void
*/
public function registerEventSignals()
{
foreach (self::$signals as $no => $name) {
if ($name === 'SIGKILL' || $name == 'SIGSTOP') {
continue;
}
$ev = event_new();
if (!event_set($ev, $no, EV_SIGNAL | EV_PERSIST, array($this, 'eventSighandler'), array($no))) {
throw new Exception('Cannot event_set for ' . $name . ' signal');
}
event_base_set($ev, $this->eventBase);
event_add($ev);
$this->sigEvents[$no] = $ev;
}
}
protected function addSocketEvent()
{
$event = event_new();
if (!event_set($event, $this->socket, EV_READ | EV_PERSIST, array($this, 'onEventAccept'))) {
throw new RuntimeException("Can't set event");
}
if (false === event_base_set($event, $this->event_base)) {
throw new RuntimeException("Can't set [{$socket_num}] event base.");
}
if (false === event_add($event)) {
throw new RuntimeException("Can't add event");
}
$this->socket_events = $event;
self::log('Socket', 'event added');
}
public function start()
{
$n = 0;
foreach ($this->fds as $fd) {
++$n;
$event = 'event#' . $n;
stream_set_blocking($fd, 0);
$event = event_new();
event_set($event, $fd, EV_READ | EV_PERSIST, $this->eventcb[(int) $fd], $this->ev_base);
event_base_set($event, $this->ev_base);
event_add($event);
$this->events[] = $event;
}
$this->run();
}
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);
}
public static function initEvent()
{
if (!self::$supported) {
return;
}
self::updateConfig();
self::$ev = event_new();
self::$fd = eio_get_event_stream();
event_set(self::$ev, self::$fd, EV_READ | EV_PERSIST, function ($fd, $events, $arg) {
if (eio_nreqs()) {
eio_poll();
}
});
event_base_set(self::$ev, Daemon::$process->eventBase);
event_add(self::$ev);
}
/**
* Constructor
* @param object Parent AppInstance.
* @param object Upstream.
* @param object Source request.
* @return void
*/
public function __construct($appInstance, $upstream, $parent = NULL)
{
$this->appInstance = $appInstance;
$this->upstream = $upstream;
$this->idAppQueue = ++$this->appInstance->idAppQueue;
$this->appInstance->queue[$this->idAppQueue] = $this;
$this->queueId = isset($parent->queueId) ? $parent->queueId : ++Daemon::$process->reqCounter;
Daemon::$process->queue[$this->queueId] = $this;
$this->ev = event_new();
event_set($this->ev, STDIN, EV_TIMEOUT, array('Request', 'eventCall'), array($this->queueId));
event_base_set($this->ev, Daemon::$process->eventBase);
event_add($this->ev, 1);
$this->preinit($parent);
$this->onWakeup();
$this->init();
$this->onSleep();
}
