घटना विस्तार
घटना विस्तार बहुत उपयुक्त है। यह लिबवेंट लाइब्रेरी का एक बंदरगाह है जो मुख्य रूप से नेटवर्किंग के लिए इवेंट-संचालित I / O के लिए डिज़ाइन किया गया है।
मैंने एक नमूना HTTP क्लाइंट लिखा है जो कई HTTP अनुरोधों को शेड्यूल करने और उन्हें एसिंक्रोनस रूप से चलाने की अनुमति देता है।
यह ईवेंट एक्सटेंशन के आधार पर एक नमूना HTTP क्लाइंट क्लास है ।
वर्ग कई HTTP अनुरोधों को शेड्यूल करने की अनुमति देता है, फिर उन्हें अतुल्यकालिक रूप से चलाएं।
http-client.php
<?php
class MyHttpClient {
/// @var EventBase
protected $base;
/// @var array Instances of EventHttpConnection
protected $connections = [];
public function __construct() {
$this->base = new EventBase();
}
/**
* Dispatches all pending requests (events)
*
* @return void
*/
public function run() {
$this->base->dispatch();
}
public function __destruct() {
// Destroy connection objects explicitly, don't wait for GC.
// Otherwise, EventBase may be free'd earlier.
$this->connections = null;
}
/**
* @brief Adds a pending HTTP request
*
* @param string $address Hostname, or IP
* @param int $port Port number
* @param array $headers Extra HTTP headers
* @param int $cmd A EventHttpRequest::CMD_* constant
* @param string $resource HTTP request resource, e.g. '/page?a=b&c=d'
*
* @return EventHttpRequest|false
*/
public function addRequest($address, $port, array $headers,
$cmd = EventHttpRequest::CMD_GET, $resource = '/')
{
$conn = new EventHttpConnection($this->base, null, $address, $port);
$conn->setTimeout(5);
$req = new EventHttpRequest([$this, '_requestHandler'], $this->base);
foreach ($headers as $k => $v) {
$req->addHeader($k, $v, EventHttpRequest::OUTPUT_HEADER);
}
$req->addHeader('Host', $address, EventHttpRequest::OUTPUT_HEADER);
$req->addHeader('Connection', 'close', EventHttpRequest::OUTPUT_HEADER);
if ($conn->makeRequest($req, $cmd, $resource)) {
$this->connections []= $conn;
return $req;
}
return false;
}
/**
* @brief Handles an HTTP request
*
* @param EventHttpRequest $req
* @param mixed $unused
*
* @return void
*/
public function _requestHandler($req, $unused) {
if (is_null($req)) {
echo "Timed out\n";
} else {
$response_code = $req->getResponseCode();
if ($response_code == 0) {
echo "Connection refused\n";
} elseif ($response_code != 200) {
echo "Unexpected response: $response_code\n";
} else {
echo "Success: $response_code\n";
$buf = $req->getInputBuffer();
echo "Body:\n";
while ($s = $buf->readLine(EventBuffer::EOL_ANY)) {
echo $s, PHP_EOL;
}
}
}
}
}
$address = "my-host.local";
$port = 80;
$headers = [ 'User-Agent' => 'My-User-Agent/1.0', ];
$client = new MyHttpClient();
// Add pending requests
for ($i = 0; $i < 10; $i++) {
$client->addRequest($address, $port, $headers,
EventHttpRequest::CMD_GET, '/test.php?a=' . $i);
}
// Dispatch pending requests
$client->run();
test.php
यह सर्वर पर एक नमूना स्क्रिप्ट है।
<?php
echo 'GET: ', var_export($_GET, true), PHP_EOL;
echo 'User-Agent: ', $_SERVER['HTTP_USER_AGENT'] ?? '(none)', PHP_EOL;
प्रयोग
php http-client.php
नमूना आउटपुट
Success: 200
Body:
GET: array (
'a' => '1',
)
User-Agent: My-User-Agent/1.0
Success: 200
Body:
GET: array (
'a' => '0',
)
User-Agent: My-User-Agent/1.0
Success: 200
Body:
GET: array (
'a' => '3',
)
...
(काट दिया था।)
ध्यान दें, कोड CLI SAPI में दीर्घकालिक प्रसंस्करण के लिए डिज़ाइन किया गया है ।
कस्टम प्रोटोकॉल के लिए, निम्न स्तर के एपीआई का उपयोग कर, यानी पर विचार घटनाओं बफ़र , बफ़र्स । एसएसएल / टीएलएस संचार के लिए, मैं इवेंट के एसएसएल संदर्भ के साथ निम्न-स्तरीय एपीआई की सिफारिश करूंगा । उदाहरण:
हालांकि लिबवेंट का HTTP एपीआई सरल है, यह बफर इवेंट्स की तरह लचीला नहीं है। उदाहरण के लिए, HTTP API वर्तमान में कस्टम HTTP विधियों का समर्थन नहीं करता है। लेकिन निम्न-स्तरीय एपीआई का उपयोग करके लगभग किसी भी प्रोटोकॉल को लागू करना संभव है।
ईव एक्सटेंशन
मैंने गैर-अवरोधक मोड में सॉकेट्स के साथ ईवी एक्सटेंशन का उपयोग करके एक और HTTP क्लाइंट का एक नमूना भी लिखा है । इवेंट के आधार पर नमूने की तुलना में कोड थोड़ा अधिक क्रियाशील है, क्योंकि ईव एक सामान्य उद्देश्य ईवेंट लूप है। यह नेटवर्क-विशिष्ट फ़ंक्शंस प्रदान नहीं करता है, लेकिन इसका द्रष्टा विशेष रूप से सॉकेट संसाधन में संलग्न फ़ाइल डिस्क्रिप्टर को सुनने में सक्षम है।EvIo
यह एवी एक्सटेंशन पर आधारित एक नमूना HTTP क्लाइंट है ।
ईवी एक्सटेंशन एक सरल लेकिन शक्तिशाली सामान्य प्रयोजन ईवेंट लूप को लागू करता है। यह नेटवर्क-विशिष्ट वॉचर्स प्रदान नहीं करता है, लेकिन इसके I / O वॉचर का उपयोग सॉकेट्स के अतुल्यकालिक प्रसंस्करण के लिए किया जा सकता है ।
निम्न कोड दिखाता है कि समानांतर प्रसंस्करण के लिए HTTP अनुरोधों को कैसे निर्धारित किया जा सकता है।
http-client.php
<?php
class MyHttpRequest {
/// @var MyHttpClient
private $http_client;
/// @var string
private $address;
/// @var string HTTP resource such as /page?get=param
private $resource;
/// @var string HTTP method such as GET, POST etc.
private $method;
/// @var int
private $service_port;
/// @var resource Socket
private $socket;
/// @var double Connection timeout in seconds.
private $timeout = 10.;
/// @var int Chunk size in bytes for socket_recv()
private $chunk_size = 20;
/// @var EvTimer
private $timeout_watcher;
/// @var EvIo
private $write_watcher;
/// @var EvIo
private $read_watcher;
/// @var EvTimer
private $conn_watcher;
/// @var string buffer for incoming data
private $buffer;
/// @var array errors reported by sockets extension in non-blocking mode.
private static $e_nonblocking = [
11, // EAGAIN or EWOULDBLOCK
115, // EINPROGRESS
];
/**
* @param MyHttpClient $client
* @param string $host Hostname, e.g. google.co.uk
* @param string $resource HTTP resource, e.g. /page?a=b&c=d
* @param string $method HTTP method: GET, HEAD, POST, PUT etc.
* @throws RuntimeException
*/
public function __construct(MyHttpClient $client, $host, $resource, $method) {
$this->http_client = $client;
$this->host = $host;
$this->resource = $resource;
$this->method = $method;
// Get the port for the WWW service
$this->service_port = getservbyname('www', 'tcp');
// Get the IP address for the target host
$this->address = gethostbyname($this->host);
// Create a TCP/IP socket
$this->socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
if (!$this->socket) {
throw new RuntimeException("socket_create() failed: reason: " .
socket_strerror(socket_last_error()));
}
// Set O_NONBLOCK flag
socket_set_nonblock($this->socket);
$this->conn_watcher = $this->http_client->getLoop()
->timer(0, 0., [$this, 'connect']);
}
public function __destruct() {
$this->close();
}
private function freeWatcher(&$w) {
if ($w) {
$w->stop();
$w = null;
}
}
/**
* Deallocates all resources of the request
*/
private function close() {
if ($this->socket) {
socket_close($this->socket);
$this->socket = null;
}
$this->freeWatcher($this->timeout_watcher);
$this->freeWatcher($this->read_watcher);
$this->freeWatcher($this->write_watcher);
$this->freeWatcher($this->conn_watcher);
}
/**
* Initializes a connection on socket
* @return bool
*/
public function connect() {
$loop = $this->http_client->getLoop();
$this->timeout_watcher = $loop->timer($this->timeout, 0., [$this, '_onTimeout']);
$this->write_watcher = $loop->io($this->socket, Ev::WRITE, [$this, '_onWritable']);
return socket_connect($this->socket, $this->address, $this->service_port);
}
/**
* Callback for timeout (EvTimer) watcher
*/
public function _onTimeout(EvTimer $w) {
$w->stop();
$this->close();
}
/**
* Callback which is called when the socket becomes wriable
*/
public function _onWritable(EvIo $w) {
$this->timeout_watcher->stop();
$w->stop();
$in = implode("\r\n", [
"{$this->method} {$this->resource} HTTP/1.1",
"Host: {$this->host}",
'Connection: Close',
]) . "\r\n\r\n";
if (!socket_write($this->socket, $in, strlen($in))) {
trigger_error("Failed writing $in to socket", E_USER_ERROR);
return;
}
$loop = $this->http_client->getLoop();
$this->read_watcher = $loop->io($this->socket,
Ev::READ, [$this, '_onReadable']);
// Continue running the loop
$loop->run();
}
/**
* Callback which is called when the socket becomes readable
*/
public function _onReadable(EvIo $w) {
// recv() 20 bytes in non-blocking mode
$ret = socket_recv($this->socket, $out, 20, MSG_DONTWAIT);
if ($ret) {
// Still have data to read. Append the read chunk to the buffer.
$this->buffer .= $out;
} elseif ($ret === 0) {
// All is read
printf("\n<<<<\n%s\n>>>>", rtrim($this->buffer));
fflush(STDOUT);
$w->stop();
$this->close();
return;
}
// Caught EINPROGRESS, EAGAIN, or EWOULDBLOCK
if (in_array(socket_last_error(), static::$e_nonblocking)) {
return;
}
$w->stop();
$this->close();
}
}
/////////////////////////////////////
class MyHttpClient {
/// @var array Instances of MyHttpRequest
private $requests = [];
/// @var EvLoop
private $loop;
public function __construct() {
// Each HTTP client runs its own event loop
$this->loop = new EvLoop();
}
public function __destruct() {
$this->loop->stop();
}
/**
* @return EvLoop
*/
public function getLoop() {
return $this->loop;
}
/**
* Adds a pending request
*/
public function addRequest(MyHttpRequest $r) {
$this->requests []= $r;
}
/**
* Dispatches all pending requests
*/
public function run() {
$this->loop->run();
}
}
/////////////////////////////////////
// Usage
$client = new MyHttpClient();
foreach (range(1, 10) as $i) {
$client->addRequest(new MyHttpRequest($client, 'my-host.local', '/test.php?a=' . $i, 'GET'));
}
$client->run();
परिक्षण
मान लीजिए कि http://my-host.local/test.phpस्क्रिप्ट डंप की छपाई कर रही है $_GET:
<?php
echo 'GET: ', var_export($_GET, true), PHP_EOL;
तब php http-client.phpकमांड का आउटपुट निम्न के समान होगा:
<<<<
HTTP/1.1 200 OK
Server: nginx/1.10.1
Date: Fri, 02 Dec 2016 12:39:54 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: close
X-Powered-By: PHP/7.0.13-pl0-gentoo
1d
GET: array (
'a' => '3',
)
0
>>>>
<<<<
HTTP/1.1 200 OK
Server: nginx/1.10.1
Date: Fri, 02 Dec 2016 12:39:54 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: close
X-Powered-By: PHP/7.0.13-pl0-gentoo
1d
GET: array (
'a' => '2',
)
0
>>>>
...
(छंटनी)
नोट, पीएचपी 5 में सॉकेट विस्तार के लिए चेतावनी लॉग इन कर सकते EINPROGRESS, EAGAINहै, और EWOULDBLOCK errnoमूल्यों। इसके साथ लॉग को बंद करना संभव है
error_reporting(E_ERROR);
संहिता के "बाकी" के बारे में
मैं बस कुछ करना चाहता हूं file_get_contents(), लेकिन मेरे बाकी कोड को लागू करने से पहले खत्म करने के अनुरोध का इंतजार न करें।
नेटवर्क अनुरोध के साथ समानांतर में चलने वाला कोड उदाहरण के लिए , ईवेंट टाइमर या ईव के निष्क्रिय वॉचर के कॉलबैक के भीतर निष्पादित किया जा सकता है । ऊपर बताए गए नमूनों को देखकर आप इसका आसानी से पता लगा सकते हैं। अन्यथा, मैं एक और उदाहरण जोड़ूंगा :)
