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();
 }

 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;
     }
 }