/** * {@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; }
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; }
protected function initEvents() { $self = $this; $this->lEvent = event_new(); event_set($this->lEvent, $this->handle, EV_READ | EV_PERSIST, array($this, 'handleEvent')); \EventPHP\Events\Loop::getInstance()->add($this->lEvent); }
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 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(); }
/** * Initialize a new stream listener */ public function __construct($stream) { $this->stream = $stream; stream_set_blocking($this->stream, 0); $meta = stream_get_meta_data($this->stream); if (substr($meta['mode'], -1) === '+') { $this->writable = true; $this->readable = true; } else { if (strpos($meta['mode'], 'r') !== false) { $this->readable = true; } if (strpos($meta['mode'], 'w') !== false) { $this->writable = true; } } if ($this->readable) { $this->ev_read = event_new(); event_set($this->ev_read, $this->stream, EV_READ | EV_PERSIST, array($this, '_read')); Loop::attachEvent($this->ev_read); } if ($this->writable) { $this->ev_write = event_new(); event_set($this->ev_write, $this->stream, EV_WRITE | EV_PERSIST, array($this, '_write')); Loop::attachEvent($this->ev_write); } }
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); }
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 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; } }
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 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); }
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; }
/** * @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; } }
/** * 运行服务器程序 * @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 __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; } }
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(); }
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 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->queueId = isset($parent->queueId) ? $parent->queueId : ++Daemon::$process->reqCounter; $this->ev = event_new(); event_set($this->ev, STDIN, EV_TIMEOUT, array($this, 'eventCall'), array($this->queueId)); event_base_set($this->ev, Daemon::$process->eventBase); if ($this->priority !== null) { event_priority_set($this->ev, $this->priority); } event_add($this->ev, 1); $this->preinit($parent); $this->onWakeup(); $this->init(); $this->onSleep(); }
/** * 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(); }