/**
  * 关闭socket
  * @param $socket
  * @param $event
  * @return unknown_type
  */
 static function close($socket, $event = null)
 {
     if ($event) {
         event_del($event);
         event_free($event);
     }
     fclose($socket);
 }

 /**
  * Free from loop
  */
 public function __destruct()
 {
     if (!empty($this->event)) {
         event_del($this->event);
         event_free($this->event);
         unset($this->event);
     }
 }

 public function removeStream($stream)
 {
     if (isset($this->events[(int) $stream])) {
         $event = $this->events[(int) $stream];
         event_del($event);
         event_free($event);
         unset($this->events[(int) $stream]);
     }
 }

 public function free()
 {
     if (is_resource($this->ev)) {
         event_del($this->ev);
         event_free($this->ev);
     }
     if (isset($this->conn)) {
         $this->conn->freeRequest($this);
     }
 }

 public function close()
 {
     $this->log("close()");
     foreach (array_keys($this->clients) as $id) {
         $this->disconnectClient($id);
     }
     $this->clients = array();
     stream_socket_shutdown($this->socket, STREAM_SHUT_RDWR);
     event_del($this->socket_event);
     event_free($this->socket_event);
     $this->socket_event = null;
 }

 private function service($connection, $flag, $base)
 {
     $connectionId = $this->getIdByConnection($connection);
     $buffer = event_buffer_new($connection, array($this, 'onRead'), array($this, 'onWrite'), array($this, 'onError'), $connectionId);
     event_buffer_base_set($buffer, $this->base);
     event_buffer_watermark_set($buffer, EV_READ, 0, 0xffffff);
     event_buffer_priority_set($buffer, 10);
     event_buffer_enable($buffer, EV_READ | EV_WRITE | EV_PERSIST);
     $this->buffers[$connectionId] = $buffer;
     event_del($this->events[$connectionId]);
     event_free($this->events[$connectionId]);
     unset($this->events[$connectionId]);
 }

 public function onRequest($clientSocket, $events, $arg)
 {
     try {
         //$transport = new TBufferedTransport(new TNonblockingSocket($clientSocket));
         $transport = new TNonblockingSocket($clientSocket);
         call_user_func($this->callback, $transport);
     } catch (Exception $e) {
         \event_del($arg[0]);
         \event_free($arg[0]);
         // close socket
         @stream_socket_shutdown($clientSocket, STREAM_SHUT_RDWR);
         @fclose($clientSocket);
         return;
     }
 }

 /**
  * Free from loop and close the stream
  */
 public function __destruct()
 {
     if (!empty($this->ev_read)) {
         event_del($this->ev_read);
         event_free($this->ev_read);
         unset($this->ev_read);
     }
     if (!empty($this->ev_write)) {
         event_del($this->ev_write);
         event_free($this->ev_write);
         unset($this->ev_write);
     }
     if (!empty($this->stream)) {
         fclose($this->stream);
         unset($this->stream);
     }
 }

 public function removeStream($stream)
 {
     $id = (int) $stream;
     if (isset($this->events[$id])) {
         $event = $this->events[$id];
         unset($this->events[$id], $this->flags[$id], $this->readCallbacks[$id], $this->writeCallbacks[$id]);
         event_del($event);
         event_free($event);
     }
 }

 /**
  * Unregister a stream
  * 
  * @param   resource    $stream
  * @param   integer     $type
  * @return  this
  */
 public function remove($stream, $type = null)
 {
     $i = (int) $stream;
     $type = is_null($type) ? array(self::READ, self::WRITE) : array($type);
     // using libevent
     if ($this->evbase) {
         foreach ($type as $t) {
             if (isset($this->streams[$t])) {
                 event_del($this->streams[$t][$i]);
                 event_free($this->streams[$t][$i]);
             }
         }
     } else {
         foreach ($type as $t) {
             unset($this->streams[$t][$i], $this->handlers[$t][$i]);
         }
     }
     return $this;
 }

 /**
  * Disable all events of sockets
  * @return void
  */
 public function disable()
 {
     return;
     // possible critical bug
     for (; sizeof($this->socketEvents);) {
         if (!is_resource($ev = array_pop($this->socketEvents))) {
             continue;
         }
         event_del($ev);
         event_free($ev);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function cancelTimer(TimerInterface $timer)
 {
     if ($this->isTimerActive($timer)) {
         $event = $this->timerEvents[$timer];
         event_del($event);
         event_free($event);
         $this->timerEvents->detach($timer);
     }
 }

 private function _closeSocket($socket, $event = null)
 {
     if ($event) {
         \event_del($event);
         \event_free($event);
     }
     \stream_socket_shutdown($socket, STREAM_SHUT_RDWR);
     \fclose($socket);
 }

 /**
  * Destroy event handle
  *
  * @return void
  */
 private function destroy()
 {
     if ($this->handle) {
         event_del($this->handle);
         event_free($this->handle);
         $this->handle = null;
     }
 }

 /**
  * @codeCoverageIgnore
  */
 public function __destruct()
 {
     foreach ($this->events as $event) {
         event_free($event);
     }
 }

 public function closeConnection($connId)
 {
     if (Daemon::$settings['logevents']) {
         Daemon::log('[WORKER ' . Daemon::$worker->pid . '] closeConnection(' . $connId . ').');
     }
     if (!isset($this->buf[$connId])) {
         return;
     }
     if (isset($this->readEvents[$connId])) {
         event_del($this->readEvents[$connId]);
         event_free($this->readEvents[$connId]);
         unset($this->readEvents[$connId]);
     }
     event_buffer_free($this->buf[$connId]);
     if (Daemon::$useSockets) {
         socket_close(Daemon::$worker->pool[$connId]);
     } else {
         fclose(Daemon::$worker->pool[$connId]);
     }
     unset(Daemon::$worker->pool[$connId]);
     unset(Daemon::$worker->poolApp[$connId]);
     unset(Daemon::$worker->readPoolState[$connId]);
     unset($this->buf[$connId]);
     unset($this->poolQueue[$connId]);
     unset(Daemon::$worker->poolState[$connId]);
 }

 public function closeSockets()
 {
     foreach (Daemon::$socketEvents as $k => $ev) {
         event_del($ev);
         event_free($ev);
         unset($this->socketEvents[$k]);
     }
     foreach (Daemon::$sockets as $k => &$s) {
         if (Daemon::$useSockets) {
             socket_close($s[0]);
         } else {
             fclose($s[0]);
         }
         unset(Daemon::$sockets[$k]);
     }
 }

 public function cancelTimer($signature)
 {
     if (isset($this->timers[$signature])) {
         $timer = $this->timers[$signature];
         $timer->cancelled = true;
         event_del($timer->resource);
         event_free($timer->resource);
         unset($this->timers[$signature]);
     }
 }

 /**
  * Close the connection
  * @param integer Connection's ID
  * @return void
  */
 public function close()
 {
     if (!isset($this->buffer)) {
         return;
     }
     if (isset($this->event)) {
         event_del($this->event);
         event_free($this->event);
         $this->event = null;
     }
     event_buffer_free($this->buffer);
     $this->buffer = null;
     if (isset($this->fd)) {
         $this->closeFd();
     }
 }

 private function become_intern($request_message)
 {
     $intern = new Prefork_Intern($this);
     $pid = $this->fork_process();
     if ($pid === 0) {
         // Interns only past this point
         event_base_loopbreak($this->event_base);
         event_base_reinit($this->event_base);
         foreach ($this->events as $i => $event) {
             event_del($event);
             event_free($event);
             unset($this->events[$i]);
         }
         event_base_free($this->event_base);
         $intern->start_request($request_message);
         $this->intern = $intern;
         return true;
     }
     $this->intern_pid = $pid;
     if (!$this->single_interns) {
         $this->make_offer();
     }
     return false;
 }