public function query($text)
    {
        $head = <<<_HEADER_
<?xml version="1.0" ?>
<wordsegmentation version="0.1">
<option showcategory="1" />
<authentication username="{$this->user}" password="{$this->passwd}" />
<text>
_HEADER_;
        $footer = <<<_FOOT_
</text>
</wordsegmentation>
_FOOT_;
        $this->data_send = $text;
        $text = str_replace("&", " ", $text);
        $querystr = $head . $text . $footer;
        $tempxml = simplexml_load_string($querystr);
        $resp = array();
        if ($tempxml) {
            if (stream_socket_sendto($this->sock, $tempxml->asXML())) {
                do {
                    $ttt = stream_socket_recvfrom($this->sock, 65525);
                    $ttt = iconv('big5', 'utf-8', $ttt);
                    $resp[] = $ttt;
                } while (!simplexml_load_string(implode($resp)));
                return $this->data_recv = html_entity_decode(implode($resp));
            }
        } else {
            $this->data_recv = 0;
            return null;
        }
    }

 public function processMessage($message, $client)
 {
     $event = $message->event;
     $data = $message->data;
     $uuid = $message->uuid;
     if ($event == "beforeEach") {
         $data = $this->runner->runBeforeEachHooksForTransaction($data);
         $data = $this->runner->runBeforeHooksForTransaction($data);
     }
     if ($event == "beforeEachValidation") {
         $data = $this->runner->runBeforeEachValidationHooksForTransaction($data);
         $data = $this->runner->runBeforeValidationHooksForTransaction($data);
     }
     if ($event == "afterEach") {
         $data = $this->runner->runAfterHooksForTransaction($data);
         $data = $this->runner->runAfterEachHooksForTransaction($data);
     }
     if ($event == "beforeAll") {
         $data = $this->runner->runBeforeAllHooksForTransaction($data);
     }
     if ($event == "afterAll") {
         $data = $this->runner->runAfterAllHooksForTransaction($data);
     }
     $messageToSend = ['uuid' => $uuid, 'data' => $data, 'event' => $event];
     $messageToSend = json_encode($messageToSend);
     stream_socket_sendto($client, $messageToSend . self::MESSAGE_END);
 }

 /**
  * 发送UDP数据包
  * @param $data
  * @param $port
  */
 static function _send_udp($data, $port)
 {
     if (self::$enable) {
         $cli = stream_socket_client('udp://' . self::$sc_svr_ip . ':' . $port, $errno, $errstr);
         stream_socket_sendto($cli, $data);
     }
 }

 public function close_moniter()
 {
     $dmainid = trim($_POST['dmainid']);
     //$dmain = trim($_POST['dmain']);
     $dmain_list_db = new Dmain_list();
     $val = $dmain_list_db->close_moniter($dmainid);
     $list = [];
     if (is_array($val) && count($val) > 0) {
         foreach ($val as $value) {
             $list[] = $value->dmain;
         }
     }
     if (count($list) > 0) {
         $list = implode('|', $list);
     } else {
         $list = '';
     }
     //写入redis共享给udp服务器
     $redis = $this->getRedis();
     $dmain_list = $redis->set('dmain', $list);
     $socket = stream_socket_client('udp://211.151.98.92:9501');
     $data = ['control' => 'reload'];
     $data = json_encode($data) . '\\r\\n';
     if (!$socket) {
         exit(json_encode(false));
     } else {
         stream_socket_sendto($socket, $data);
         exit(json_encode(true));
     }
 }

 /**
  * {@inheritdoc}
  */
 public function write($string)
 {
     if (!$this->isWritable()) {
         throw new RuntimeException("Stream is not writable");
     }
     return stream_socket_sendto($this->getContext(), $string);
 }

 /**
  * {@inheritdoc}
  */
 public function write($data = null)
 {
     if (isset($this->stream) === false) {
         $this->createStream();
     }
     @stream_socket_sendto($this->stream, $data);
     return true;
 }

 /**
  * 发送数据给统计系统
  * @param string $address
  * @param string $buffer
  * @return boolean
  */
 public static function sendData($address, $buffer)
 {
     $socket = stream_socket_client($address);
     if (!$socket) {
         return false;
     }
     return stream_socket_sendto($socket, $buffer) == strlen($buffer);
 }

 /**
  * Send the data
  *
  * @param $data
  *
  * @return mixed
  */
 public function write($data = null)
 {
     $host = sprintf('udp://%s:%d', $this->config['host'], $this->config['port']);
     // stream the data using UDP and suppress any errors
     $stream = @stream_socket_client($host);
     @stream_socket_sendto($stream, $data);
     @fclose($stream);
     return true;
 }

 /**
  * 发送数据给统计系统
  * @param string $address        	
  * @param string $buffer        	
  * @return boolean
  */
 public static function sendData($address, $buffer, $timeout = 10)
 {
     $socket = stream_socket_client('tcp://' . $address, $errno, $errmsg, $timeout);
     if (!$socket) {
         return false;
     }
     stream_set_timeout($socket, $timeout);
     return stream_socket_sendto($socket, $buffer) == strlen($buffer);
 }

 function request($request)
 {
     try {
         $dt = call_user_func($this->callback, NULL, $request);
         if (!empty($dt['data'])) {
             stream_socket_sendto($this->srv, $dt['data'], 0, $this->cli);
         }
     } catch (Exception $e) {
         cy_log(CYE_ERROR, "exception while processing.");
     }
 }

 public function run()
 {
     $result = $this->_server->parse($this->_data);
     if (empty($result['a'])) {
         $data = $this->_data;
     } else {
         $this->_server = $this->route($this->_server);
         $data = $this->_server->getData();
     }
     \stream_socket_sendto($this->_conn, $data . "\n");
 }

 /**
  * Sends data on the connection.
  *
  * @param string $send_buffer
  * @param bool   $raw
  * @return void|boolean
  */
 public function send($send_buffer, $raw = false)
 {
     if (false === $raw && $this->protocol) {
         $parser = $this->protocol;
         $send_buffer = $parser::encode($send_buffer, $this);
         if ($send_buffer === '') {
             return null;
         }
     }
     return strlen($send_buffer) === stream_socket_sendto($this->_socket, $send_buffer, 0, $this->_remoteAddress);
 }

 protected function pingUdp($target, $data)
 {
     if (!$this->monSocket) {
         $this->monSocket = stream_socket_client($target, $errno, $errstr);
     }
     if ($this->monSocket) {
         $post = http_build_query($data, '', '&');
         stream_socket_sendto($this->monSocket, $post);
     } else {
         common_log(LOG_ERR, __METHOD__ . " UDP logging fail: {$errstr}");
     }
 }

    public function add($response)
    {
        $contentLength = strlen($response);
        $httpResponse = 'HTTP/1.0 200 OK
Date: ' . (new \DateTime())->format(\DateTIme::RFC822) . '
Server: PHP Robot Framework Remote Server
Connection: close
Content-Type: text/xml
Content-Length: ' . $contentLength . "\r\n" . "\r\n" . $response;
        stream_socket_sendto($this->requestSocket, $httpResponse);
        stream_socket_shutdown($this->requestSocket, STREAM_SHUT_RDWR);
    }

 public function writeSync($data)
 {
     if ($this->writeEvent) {
         $this->loop->removeWriteStream($this->connection);
         $this->writeEvent = false;
     }
     $this->dataBuffer .= $this->buffer->encodeMessage(serialize($data));
     while (strlen($this->dataBuffer) > 0) {
         $this->ThrowOnConnectionInvalid();
         $dataWritten = stream_socket_sendto($this->connection, $this->dataBuffer);
         $this->dataBuffer = substr($this->dataBuffer, $dataWritten);
     }
 }

 /**
  * send data to client
  */
 public function write($data)
 {
     $data = strval($data);
     $length = strlen($data);
     if ($length == 0) {
         return 0;
     }
     /* in case of send failed */
     $alreay_sent = 0;
     while ($alreay_sent < $length) {
         $alreay_sent += stream_socket_sendto($this->_socket, substr($data, $alreay_sent));
     }
     return $length;
 }

 protected function waitChild()
 {
     if (!$this->pid) {
         $file = sys_get_temp_dir() . '/parallel' . posix_getppid() . '.sock';
         $address = 'unix://' . $file;
         $result = $this->run();
         if ($client = stream_socket_client($address)) {
             stream_socket_sendto($client, serialize([posix_getpid(), $result]));
             fclose($client);
         }
         posix_kill(posix_getpid(), SIGHUP);
         return;
     }
 }

 function handleSend()
 {
     $pkt = array_shift($this->packets);
     if ($pkt['peer'] !== null) {
         stream_socket_sendto($this->sock, $pkt['data'], 0, $pkt['peer']);
     } else {
         stream_socket_sendto($this->sock, $pkt['data']);
     }
     $this->packet = null;
     $this->emit('sent', array($pkt));
     if (count($this->packets) == 0) {
         $this->listening = false;
         $this->loop->removeWriteStream($this->sock);
         $this->emit('sent-all');
     }
 }

 protected function pollData($address, $port, $command)
 {
     $this->_logger->log(__METHOD__, array('address' => $address, 'port' => $port, 'command' => $command));
     $timeout = 6;
     // !!! PROTOCOL (TCP by default) SHOULD BE IN LOWER CASE !!!
     $uri = 'tcp' . '://' . $address . ':' . $port;
     $this->_logger->log(__METHOD__ . ': Trying to connect', array('uri' => $uri, 'timeout' => $timeout));
     // creates socket connection with IP:port
     $client = @stream_socket_client($uri, $errno, $errstr, $timeout, STREAM_CLIENT_CONNECT);
     if ($client === false) {
         $this->_logger->log(__METHOD__ . ': Client connect error', array('error' => $errstr, 'number' => $errno));
         return false;
     }
     @stream_set_timeout($client, $timeout);
     $this->_logger->log(__METHOD__ . ': Sending command', array('command' => $command));
     $status = @stream_socket_sendto($client, $command . "\n");
     if ($status === false) {
         $erroInfo = $this->getSocketErrorInfo($client);
         $this->_logger->log(__METHOD__ . ': Error on sending command', array('error' => $erroInfo['error'], 'number' => $erroInfo['number']));
         @stream_socket_shutdown($client, STREAM_SHUT_RDWR);
         return false;
     }
     $this->_logger->log(__METHOD__ . ': Sent result', array('Bytes sent' => $status));
     //$time = 0;
     $line = null;
     $message = '';
     $attempt = 1;
     $this->_logger->log(__METHOD__ . ': Starting to read response.');
     // Wait for message end
     while (strpos($line, '$') === false) {
         $line = @fread($client, 1024);
         $this->_logger->log(__METHOD__, array('read line' => $line));
         if (strlen($line) === 0) {
             $this->_logger->log(__METHOD__ . ': Reading timeout exceeded.', array('attempt' => $attempt));
             if ($attempt > 2) {
                 $this->_logger->log(__METHOD__ . ': Exceeded maximun attempt number.');
                 @stream_socket_shutdown($client, STREAM_SHUT_RDWR);
                 return false;
             }
         }
         $message .= $line;
         $attempt++;
     }
     @stream_socket_shutdown($client, STREAM_SHUT_RDWR);
     $this->_logger->log(__METHOD__, array('return' => $message));
     return $message;
 }

 public function write()
 {
     $this->notifyNext(new StreamEvent("/datagram/sending", $this));
     if ($this->remoteAddress === null) {
         // do not use fwrite() as it obeys the stream buffer size and
         // packets are not to be split at 8kb
         $ret = @stream_socket_sendto($this->socket, $this->data);
     } else {
         $ret = @stream_socket_sendto($this->socket, $this->data, 0, $this->remoteAddress);
     }
     if ($ret < 0 || $ret === false) {
         $error = error_get_last();
         $this->notifyError(new \Exception('Unable to send packet: ' . trim($error['message'])));
         return;
     }
     $this->notifyCompleted();
     $this->loop->removeWriteStream($this->socket);
 }