WebSocket Client

其实Swoole官方是有提供web socket client的例子的，在源码的example里面，鉴于很多人都招不到，我就做下搬运工。
直接上代码

  1. class WebSocketClient
  2. {
  3.     const VERSION = '0.1.4';
  5.     const TOKEN_LENGHT = 16;
  6.     const TYPE_ID_WELCOME = 0;
  7.     const TYPE_ID_PREFIX = 1;
  8.     const TYPE_ID_CALL = 2;
  9.     const TYPE_ID_CALLRESULT = 3;
  10.     const TYPE_ID_ERROR = 4;
  11.     const TYPE_ID_SUBSCRIBE = 5;
  12.     const TYPE_ID_UNSUBSCRIBE = 6;
  13.     const TYPE_ID_PUBLISH = 7;
  14.     const TYPE_ID_EVENT = 8;
  16.     const OPCODE_CONTINUATION_FRAME = 0x0;
  17.     const OPCODE_TEXT_FRAME         = 0x1;
  18.     const OPCODE_BINARY_FRAME       = 0x2;
  19.     const OPCODE_CONNECTION_CLOSE   = 0x8;
  20.     const OPCODE_PING               = 0x9;
  21.     const OPCODE_PONG               = 0xa;
  23.     const CLOSE_NORMAL              = 1000;
  24.     const CLOSE_GOING_AWAY          = 1001;
  25.     const CLOSE_PROTOCOL_ERROR      = 1002;
  26.     const CLOSE_DATA_ERROR          = 1003;
  27.     const CLOSE_STATUS_ERROR        = 1005;
  28.     const CLOSE_ABNORMAL            = 1006;
  29.     const CLOSE_MESSAGE_ERROR       = 1007;
  30.     const CLOSE_POLICY_ERROR        = 1008;
  31.     const CLOSE_MESSAGE_TOO_BIG     = 1009;
  32.     const CLOSE_EXTENSION_MISSING   = 1010;
  33.     const CLOSE_SERVER_ERROR        = 1011;
  34.     const CLOSE_TLS                 = 1015;
  36.     private $key;
  37.     private $host;
  38.     private $port;
  39.     private $path;
  40.     /**
  41.      * @var swoole_client
  42.      */
  43.     private $socket;
  44.     private $buffer = '';
  45.     private $origin = null;
  46.     /**
  47.      * @var bool
  48.      */
  49.     private $connected = false;
  51.     /**
  52.      * @param string $host
  53.      * @param int    $port
  54.      * @param string $path
  55.      */
  56.     function __construct($host = '127.0.0.1', $port = 8080, $path = '/', $origin = null)
  57.     {
  58.         $this->host = $host;
  59.         $this->port = $port;
  60.         $this->path = $path;
  61.         $this->origin = $origin;
  62.         $this->key = $this->generateToken(self::TOKEN_LENGHT);
  63.     }
  65.     /**
  66.      * Disconnect on destruct
  67.      */
  68.     function __destruct()
  69.     {
  70.         $this->disconnect();
  71.     }
  73.     /**
  74.      * Connect client to server
  75.      *
  76.      * @return $this
  77.      */
  78.     public function connect()
  79.     {
  80.         $this->socket = new \swoole_client(SWOOLE_SOCK_TCP);
  81.         if (!$this->socket->connect($this->host, $this->port))
  82.         {
  83.             return false;
  84.         }
  85.         $this->socket->send($this->createHeader());
  86.         return $this->recv();
  87.     }
  89.     public function getSocket()
  90.     {
  91.         return $this->socket;
  92.     }
  94.     /**
  95.      * Disconnect from server
  96.      */
  97.     public function disconnect()
  98.     {
  99.         $this->connected = false;
  100.         $this->socket->close();
  101.     }
  103.     public function close($code = self::CLOSE_NORMAL, $reason = '')
  104.     {
  105.         $data = pack('n', $code) . $reason;
  106.         return $this->socket->send(swoole_websocket_server::pack($data, self::OPCODE_CONNECTION_CLOSE, true));
  107.     }
  109.     public function recv()
  110.     {
  111.         $data = $this->socket->recv();
  112.         if ($data === false)
  113.         {
  114.             echo "Error: {$this->socket->errMsg}";
  115.             return false;
  116.         }
  117.         $this->buffer .= $data;
  118.         $recv_data = $this->parseData($this->buffer);
  119.         if ($recv_data)
  120.         {
  121.             $this->buffer = '';
  122.             return $recv_data;
  123.         }
  124.         else
  125.         {
  126.             return false;
  127.         }
  128.     }
  130.     /**
  131.      * @param  string      $data
  132.      * @param string $type
  133.      * @param bool   $masked
  134.      * @return bool
  135.      */
  136.     public function send($data, $type = 'text', $masked = false)
  137.     {
  138.         switch($type)
  139.         {
  140.             case 'text':
  141.                 $_type = WEBSOCKET_OPCODE_TEXT;
  142.                 break;
  143.             case 'binary':
  144.             case 'bin':
  145.                 $_type = WEBSOCKET_OPCODE_BINARY;
  146.                 break;
  147.             default:
  148.                 return false;
  149.         }
  150.         return $this->socket->send(swoole_websocket_server::pack($data, $_type, true, $masked));
  151.     }
  153.     /**
  154.      * Parse received data
  155.      *
  156.      * @param $response
  157.      */
  158.     private function parseData($response)
  159.     {
  160.         if (!$this->connected)
  161.         {
  162.             $response = $this->parseIncomingRaw($response);
  163.             if (isset($response['Sec-Websocket-Accept'])
  164.                 && base64_encode(pack('H*', sha1($this->key . '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'))) === $response['Sec-Websocket-Accept']
  165.             )
  166.             {
  167.                 $this->connected = true;
  168.                 return true;
  169.             }
  170.             else
  171.             {
  172.                 throw new \Exception("error response key.");
  173.             }
  174.         }
  176.         $frame = swoole_websocket_server::unpack($response);
  177.         if ($frame)
  178.         {
  179.             return $frame->data;
  180.         }
  181.         else
  182.         {
  183.             throw new \Exception("swoole_websocket_server::unpack failed.");
  184.         }
  185.     }
  187.     /**
  188.      * Create header for websocket client
  189.      *
  190.      * @return string
  191.      */
  192.     private function createHeader()
  193.     {
  194.         $host = $this->host;
  195.         if ($host === '127.0.0.1' || $host === '0.0.0.0')
  196.         {
  197.             $host = 'localhost';
  198.         }
  199.         return "GET {$this->path} HTTP/1.1" . "\r\n" .
  200.         "Origin: {$this->origin}" . "\r\n" .
  201.         "Host: {$host}:{$this->port}" . "\r\n" .
  202.         "Sec-WebSocket-Key: {$this->key}" . "\r\n" .
  203.         "User-Agent: PHPWebSocketClient/" . self::VERSION . "\r\n" .
  204.         "Upgrade: websocket" . "\r\n" .
  205.         "Connection: Upgrade" . "\r\n" .
  206.         "Sec-WebSocket-Protocol: wamp" . "\r\n" .
  207.         "Sec-WebSocket-Version: 13" . "\r\n" . "\r\n";
  208.     }
  210.     /**
  211.      * Parse raw incoming data
  212.      *
  213.      * @param $header
  214.      *
  215.      * @return array
  216.      */
  217.     private function parseIncomingRaw($header)
  218.     {
  219.         $retval = array();
  220.         $content = "";
  221.         $fields = explode("\r\n", preg_replace('/\x0D\x0A[\x09\x20]+/', ' ', $header));
  222.         foreach ($fields as $field)
  223.         {
  224.             if (preg_match('/([^:]+): (.+)/m', $field, $match))
  225.             {
  226.                 $match[1] = preg_replace_callback('/(?<=^|[\x09\x20\x2D])./',
  227.                     function ($matches)
  228.                     {
  229.                         return strtoupper($matches[0]);
  230.                     },
  231.                     strtolower(trim($match[1])));
  232.                 if (isset($retval[$match[1]]))
  233.                 {
  234.                     $retval[$match[1]] = array($retval[$match[1]], $match[2]);
  235.                 }
  236.                 else
  237.                 {
  238.                     $retval[$match[1]] = trim($match[2]);
  239.                 }
  240.             }
  241.             else
  242.             {
  243.                 if (preg_match('!HTTP/1\.\d (\d)* .!', $field))
  244.                 {
  245.                     $retval["status"] = $field;
  246.                 }
  247.                 else
  248.                 {
  249.                     $content .= $field . "\r\n";
  250.                 }
  251.             }
  252.         }
  253.         $retval['content'] = $content;
  254.         return $retval;
  255.     }
  257.     /**
  258.      * Generate token
  259.      *
  260.      * @param int $length
  261.      *
  262.      * @return string
  263.      */
  264.     private function generateToken($length)
  265.     {
  266.         $characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"§$%&/()=[]{}';
  267.         $useChars = array();
  268.         // select some random chars:
  269.         for ($i = 0; $i < $length; $i++)
  270.         {
  271.             $useChars[] = $characters[mt_rand(0, strlen($characters) - 1)];
  272.         }
  273.         // Add numbers
  274.         array_push($useChars, rand(0, 9), rand(0, 9), rand(0, 9));
  275.         shuffle($useChars);
  276.         $randomString = trim(implode('', $useChars));
  277.         $randomString = substr($randomString, 0, self::TOKEN_LENGHT);
  278.         return base64_encode($randomString);
  279.     }
  281.     /**
  282.      * Generate token
  283.      *
  284.      * @param int $length
  285.      *
  286.      * @return string
  287.      */
  288.     public function generateAlphaNumToken($length)
  289.     {
  290.         $characters = str_split('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
  291.         srand((float)microtime() * 1000000);
  292.         $token = '';
  293.         do
  294.         {
  295.             shuffle($characters);
  296.             $token .= $characters[mt_rand(0, (count($characters) - 1))];
  297.         } while (strlen($token) < $length);
  298.         return $token;
  299.     }
  300. }

调用

  1. $opt = getopt("c:n:k:");
  2. print_r($opt);
  3. if (empty($opt['c']) || empty($opt['n']))
  4. {
  5.     echo "examples:  php client.php -c 100 -n 10000" . PHP_EOL;
  6.     return;
  7. }
  8. $clients = $opt['c'];
  9. $count = $opt['n'];
  10. $size = empty($opt['k']) ? 0 : $opt['k'];
  11. require __DIR__ . "/WebSocketClient.php";
  12. $host = '127.0.0.1';
  13. $prot = 9501;
  15. $client = new WebSocketClient($host, $prot);
  16. $data = $client->connect();
  17. //echo $data;
  18. $data = "data";
  19. if (!empty($size))
  20. {
  21.     $data = str_repeat("A", $size * 1024);
  22. }
  23. for ($i = 0; $i < $count; $i++)
  24. {
  25.     $client->send("hello swoole, number:" . $i . " data:" . $data);
  26.     $recvData = "";
  27.     //while(1) {
  28.     $tmp = $client->recv();
  29.     if (empty($tmp))
  30.     {
  31.         break;
  32.     }
  33.     $recvData .= $tmp;
  34.     //}
  35.     echo $recvData . "size:" . strlen($recvData) . PHP_EOL;
  36. }
  37. echo PHP_EOL . "======" . PHP_EOL;
  38. sleep(1);
  39. echo 'finish' . PHP_EOL;