PHP swoole_client::on方法代码示例

 public function sendData(callable $callback)
 {
     $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", function ($cli) {
         $cli->send($this->data);
     });
     $client->on('close', function ($cli) {
     });
     $client->on('error', function ($cli) use($callback) {
         $cli->close();
         call_user_func_array($callback, array('r' => 1, 'key' => $this->key, 'error_msg' => 'conncet error'));
     });
     $client->on("receive", function ($cli, $data) use($callback) {
         $cli->close();
         call_user_func_array($callback, array('r' => 0, 'key' => $this->key, 'data' => $data));
     });
     if ($client->connect($this->ip, $this->port, $this->timeout)) {
         if (intval($this->timeout) > 0) {
             swoole_timer_after(intval($this->timeout) * 1000, function () use($client, $callback) {
                 if ($client->isConnected()) {
                     $client->close();
                     call_user_func_array($callback, array('r' => 2, 'key' => '', 'error_msg' => 'timeout'));
                 }
             });
         }
     }
 }

function send()
{
    $pid = posix_getpid();
    $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
    //异步非阻塞
    $client->on("connect", function (swoole_client $cli) use($pid) {
        $data = microtime(true);
        lg("[{$pid}] Send: {$data}", __LINE__);
        $cli->send($data);
    });
    $client->on("receive", function (swoole_client $cli, $data) use($pid) {
        lg("[{$pid}] Received: {$data}", __LINE__);
        $cli->close();
    });
    $client->on("error", function (swoole_client $cli) use($pid) {
        $cli->close();
        //lg("[$pid] error then conn close", __LINE__);
        exit(0);
    });
    $client->on("close", function (swoole_client $cli) use($pid) {
        //lg("[$pid] conn close", __LINE__);
    });
    $client->connect('127.0.0.1', 8001, 0.5);
    //lg("[$pid] create conn succ", __LINE__);
    exit(0);
}

 function onConnect($serv, $fd, $from_id)
 {
     $socket = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     echo microtime() . ": Client[{$fd}] backend-sock[{$socket->sock}]: Connect.\n";
     $socket->on('connect', function (swoole_client $socket) {
         echo "connect to backend server success\n";
     });
     $socket->on('error', function (swoole_client $socket) {
         echo "connect to backend server fail\n";
         $this->serv->send($this->backends[$socket->sock]['client_fd'], "backend server not connected. please try reconnect.");
         $this->serv->close($this->backends[$socket->sock]['client_fd']);
         $socket->close();
     });
     $socket->on('close', function (swoole_client $socket) {
         echo "backend connection close\n";
     });
     $socket->on('receive', function (swoole_client $socket, $data) {
         //PHP-5.4以下版本可能不支持此写法，匿名函数不能调用$this
         //可以修改为类静态变量
         $servinst->send($this->backends[$socket->sock]['client_fd'], $data);
     });
     if ($socket->connect('61.135.169.125', 80, 1)) {
         $this->backends[$socket->sock] = array('client_fd' => $fd, 'socket' => $socket);
         $this->clients[$fd] = array('socket' => $socket);
     }
 }

 public function send(callable $callback)
 {
     $client = new \swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", function ($cli) {
         $cli->send($this->data);
     });
     $client->on('close', function ($cli) {
     });
     $client->on('error', function ($cli) use($callback) {
         $cli->close();
         call_user_func_array($callback, array('r' => 1, 'key' => $this->key, 'calltime' => $this->calltime, 'error_msg' => 'conncet error'));
     });
     $client->on("receive", function ($cli, $data) use($callback) {
         $this->calltime = microtime(true) - $this->calltime;
         $cli->close();
         call_user_func_array($callback, array('r' => 0, 'key' => $this->key, 'calltime' => $this->calltime, 'data' => $data));
     });
     if ($client->connect($this->ip, $this->port, $this->timeout, 1)) {
         $this->calltime = microtime(true);
         if (floatval($this->timeout) > 0) {
             $this->timer = swoole_timer_after(floatval($this->timeout) * 1000, function () use($client, $callback) {
                 $client->close();
                 \SysLog::error(__METHOD__ . " TIMEOUT ", __CLASS__);
                 $this->calltime = microtime(true) - $this->calltime;
                 call_user_func_array($callback, array('r' => 2, 'key' => '', 'calltime' => $this->calltime, 'error_msg' => 'timeout'));
             });
         }
     }
 }

 public function sendData($tc, $c)
 {
     $client = new swoole_client(SWOOLE_SOCK_UDP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", function ($cli) use($tc) {
         $cli->send($tc->data);
     });
     $client->on('close', function ($cli) {
     });
     $client->on('error', function ($cli) {
     });
     $client->on("receive", function ($cli, $data) use($c) {
         $cli->close();
         $tc = $c->send($data);
         if ($tc instanceof TestClient) {
             $this->sendData($tc, $c);
         } else {
             unset($c);
         }
     });
     if ($client->connect($tc->ip, $tc->port, $tc->timeout)) {
         // if (intval($tc ->timeout) >0) {
         //     swoole_timer_after(intval($tc ->timeout) * 1000, function() use($client){
         //         if ($client ->isConnected()) {
         //             $log = "timeout \n";
         //             error_log($log,3,'/tmp/timeout.log');
         //             $client ->close();
         //             $this ->callback('timeout');
         //         }
         //     });
         // }
     }
 }

 /**
  * connect to swoole server then send data
  *
  * @return string
  */
 public static function client()
 {
     $return = FALSE;
     $client = new \swoole_client(SWOOLE_SOCK_TCP);
     // set eof charactor
     $client->set(['open_eof_split' => TRUE, 'package_eof' => self::EOFF]);
     // listen on
     $client->on('connect', '\\CI_Swoole\\Client::on_connect');
     $client->on('receive', '\\CI_Swoole\\Client::on_receive');
     $client->on('error', '\\CI_Swoole\\Client::on_error');
     $client->on('close', '\\CI_Swoole\\Client::on_close');
     // connect
     $client->connect(self::HOST, self::PORT, 10);
     // send data
     if ($client->isConnected()) {
         $post = serialize(static::$post);
         $post .= self::EOFF;
         $issend = $client->send($post);
     }
     // receiv data
     if (isset($issend) && $issend) {
         $return = @$client->recv();
         $return = str_replace(self::EOFF, '', $return);
         $return = unserialize($return);
     }
     $client->close();
     unset($client);
     return $return;
 }

 public function createBackend()
 {
     $backend = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $backend->on('connect', function ($cli) {
         echo "backend connect.\n";
     });
     $backend->on('receive', function ($cli, $data) {
         echo "backend receive.\n";
         $fd = (int) $cli->sock;
         if (!empty($this->b2c[$fd]['fd'])) {
             $this->server->send($this->b2c[$fd]['fd'], $data);
         }
     });
     $backend->on('close', function ($cli) {
         if (!empty($cli)) {
             $this->backendReconnect($cli);
             //$this->clearClient((int)$cli->sock, $from_client=false);
         }
     });
     $backend->on('error', function ($cli) {
         echo "error\n";
     });
     $backend->connect($this->backend_info['ip'], $this->backend_info['port']);
     return $backend;
 }

 public function sendData(callable $callback)
 {
     $client = new swoole_client(SWOOLE_SOCK_UDP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", function ($cli) {
         $this->isConnect = true;
         $cli->send($this->data);
     });
     $client->on('close', function ($cli) {
         $this->isConnect = false;
     });
     $client->on('error', function ($cli) use($callback) {
         $this->isConnect = false;
         $cli->close();
         call_user_func_array($callback, array('r' => 1, 'key' => $this->key, 'error_msg' => 'conncet error'));
     });
     $client->on("receive", function ($cli, $data) use($callback) {
         $this->isConnect = false;
         $cli->close();
         call_user_func_array($callback, array('r' => 0, 'key' => $this->key, 'data' => $data));
     });
     if ($client->connect($this->ip, $this->port, $this->timeout)) {
         if (intval($this->timeout) > 0) {
             swoole_timer_after(intval($this->timeout) * 1000, function () use($client, $callback) {
                 if ($this->isConnect) {
                     //error_log(__METHOD__." client ===== ".print_r($client,true),3,'/tmp/client.log');
                     $client->close();
                     call_user_func_array($callback, array('r' => 2, 'key' => '', 'error_msg' => 'timeout'));
                 }
             });
         }
     }
 }

 public function run(Promise &$promise)
 {
     $cli = new \swoole_client(SWOOLE_TCP, SWOOLE_SOCK_ASYNC);
     $urlInfo = parse_url($this->url);
     $timeout = $this->timeout;
     if (!isset($urlInfo['port'])) {
         $urlInfo['port'] = 80;
     }
     $httpParser = new \HttpParser();
     $cli->on("connect", function ($cli) use($urlInfo, &$timeout, &$promise) {
         $cli->isConnected = true;
         $host = $urlInfo['host'];
         if ($urlInfo['port']) {
             $host .= ':' . $urlInfo['port'];
         }
         $req = array();
         $req[] = "GET {$this->url} HTTP/1.1\r\n";
         $req[] = "User-Agent: PHP swAsync\r\n";
         $req[] = "Host:{$host}\r\n";
         $req[] = "Connection:close\r\n";
         $req[] = "\r\n";
         $req = implode('', $req);
         $cli->send($req);
     });
     $cli->on("receive", function ($cli, $data = "") use(&$httpParser, &$promise) {
         $ret = $httpParser->execute($data);
         if ($ret !== false) {
             Timer::del($cli->sock);
             $cli->isDone = true;
             if ($cli->isConnected()) {
                 $cli->close();
             }
             $promise->accept(['http_data' => $ret]);
         }
     });
     $cli->on("error", function ($cli) use(&$promise) {
         Timer::del($cli->sock);
         $promise->accept(['http_data' => null, 'http_error' => 'Connect error']);
     });
     $cli->on("close", function ($cli) use(&$promise) {
     });
     if ($this->proxy) {
         $cli->connect($this->proxy['host'], $this->proxy['port'], 0.05);
     } else {
         $cli->connect($urlInfo['host'], $urlInfo['port'], 0.05);
     }
     $cli->isConnected = false;
     if (!$cli->errCode) {
         Timer::add($cli->sock, $this->timeout, function () use($cli, &$promise) {
             @$cli->close();
             if ($cli->isConnected) {
                 $promise->accept(['http_data' => null, 'http_error' => 'Http client read timeout']);
             } else {
                 $promise->accept(['http_data' => null, 'http_error' => 'Http client connect timeout']);
             }
         });
     }
 }

 public function connect($client)
 {
     $this->socket = new \swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $this->socket->on('Connect', array($client, 'onConnect'));
     $this->socket->on('Receive', array($client, 'onReceive'));
     $this->socket->on('Close', array($client, 'onClose'));
     $this->socket->on('Error', array($client, 'onError'));
     if (!$this->socket->connect($this->host, $this->port)) {
         return false;
     }
     return true;
 }

 /**
  * 创建一个新的客户端
  */
 static function create()
 {
     $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", 'G::onConnect');
     $client->on("receive", 'G::onReceive');
     $client->on("error", function (swoole_client $cli) {
         echo "error\n";
     });
     $client->on("close", 'G::onClose');
     $client->connect('127.0.0.1', 9502);
     self::$count++;
     self::putLog("CREATE#" . $client->sock . "\$");
 }

 /**
  * 数据发送
  *
  * @param $msg
  * @return mixed
  */
 public function send($msg)
 {
     $client = new \swoole_client(SWOOLE_SOCK_UDP, SWOOLE_SOCK_ASYNC);
     $client->on('connect', function ($cli) use($msg) {
         try {
             $cli->send($msg);
         } catch (\Exception $e) {
         }
     });
     $client->on("receive", [$this, "onReceive"]);
     $client->on('close', [$this, 'onClose']);
     $client->on('error', [$this, 'onError']);
     return $client->connect($this->host, $this->port, $this->timeOut, true);
 }

 public function addServerClient($address)
 {
     $client = new swoole_client(SWOOLE_TCP, SWOOLE_SOCK_ASYNC);
     $client->on('Connect', array(&$this, 'onConnect'));
     $client->on('Receive', array(&$this, 'onReceive'));
     $client->on('Close', array(&$this, 'onClose'));
     $client->on('Error', array(&$this, 'onError'));
     $config_obj = Yaf_Registry::get("config");
     $distributed_config = $config_obj->distributed->toArray();
     $client->connect($address, $distributed_config['port']);
     $this->cur_address = $address;
     $this->table->set(ip2long($address), array('clientfd' => ip2long($address)));
     $this->b_client_pool[ip2long($address)] = $client;
     return $client;
 }

 function connect($host, $port)
 {
     if (empty($this->host)) {
         $this->host = $host;
         $this->port = $port;
     }
     $client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
     $client->on("connect", [$this, 'onConnect']);
     $client->on("receive", function (swoole_client $cli, $data) {
         $cli->send("HELLO");
         echo "recv from server: {$data}\n";
         usleep(100000);
     });
     $client->on("error", [$this, 'onError']);
     $client->on("close", [$this, 'onClose']);
     $client->connect($host, $port);
     $this->swoole_client = $client;
 }

 public static function request(callable $callback, $url, $method = 'GET', array $headers = [], array $params = [])
 {
     $parsed_url = parse_url($url);
     \swoole_async_dns_lookup($parsed_url['host'], function ($host, $ip) use($parsed_url, $callback, $url, $method, $headers, $params) {
         $port = isset($parsed_url['port']) ? $parsed_url['port'] : 'https' == $parsed_url['scheme'] ? 443 : 80;
         $client = new \swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);
         $method = strtoupper($method);
         $client->on("connect", function ($cli) use($url, $method, $parsed_url, $headers, $params) {
             \ZPHP\Common\AsyncHttpClient::clear($cli);
             $path = isset($parsed_url['path']) ? $parsed_url['path'] : '/';
             if (!empty($params)) {
                 $query = http_build_query($params);
                 if ('GET' == $method) {
                     $path .= "?" . $query;
                 }
             }
             $sendData = $method . " {$path} HTTP/1.1\r\n";
             $headers = array('Host' => $parsed_url['host'], 'Connection' => 'keep-alive', 'Pragma' => 'no-cache', 'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8', 'User-Agent' => 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.80 Safari/537.36', 'Referer' => $url, 'Accept-Encoding' => 'gzip, deflate, sdch', 'Accept-Language' => 'zh-CN,zh;q=0.8') + $headers;
             foreach ($headers as $key => $val) {
                 $sendData .= "{$key}: {$val}\r\n";
             }
             if ('POST' === $method) {
                 $sendData .= "Content-Length: " . strlen($query) . "\r\n";
                 $sendData .= "\r\n" . $query;
             } else {
                 $sendData .= "\r\n";
             }
             $cli->send($sendData);
         });
         $client->on("receive", function ($cli, $data) use($callback) {
             $ret = self::parseBody($cli, $data, $callback);
             if (is_array($ret)) {
                 call_user_func_array($callback, array($cli, $ret));
             }
         });
         $client->on("error", function ($cli) {
             \ZPHP\Common\AsyncHttpClient::clear($cli);
         });
         $client->on("close", function ($cli) {
             \ZPHP\Common\AsyncHttpClient::clear($cli);
         });
         $client->connect($ip, $port);
     });
 }