public function listen($port, $host = '127.0.0.1', $backlog = 100)
{
$this->port = $port;
$this->host = $host;
$self = $this;
$system = $this->getSystem();
$this->server = uv_tcp_init();
$request = $self->getServerRequest();
$response = $self->getServerResponse();
$requestListener = $self->getRequestListener();
uv_tcp_bind($this->server, uv_ip4_addr($host, $port));
uv_listen($this->server, $backlog, function ($server) use($self, &$request, &$response, &$requestListener) {
$client = uv_tcp_init();
uv_accept($server, $client);
uv_read_start($client, function ($socket, $nread, $buffer) use($self, &$request, &$response, &$requestListener) {
$self->generateServerVariables($buffer, $socket);
call_user_func_array($requestListener, array($request, $response));
$status_code = $response->getStatusCode();
$statusMessage = $response->getReasonPhrase();
$headers = $response->getHeaders();
$header = "";
if (count($headers) > 0) {
foreach ($headers as $key => $val) {
$header .= $key . ": " . $val . "\r\n";
}
}
$output = $response->getData();
$buffer = "HTTP/1.1 {$status_code} {$statusMessage}\r\n{$header}\r\n{$output}";
uv_write($socket, $buffer);
uv_close($socket);
});
});
}
public function end()
{
// Todo: implement correctly
$buffer = "HTTP/1.0 200 OK\r\n";
foreach ($this->headers as $key => $value) {
$buffer .= $key . ": " . $value . "\r\n";
}
$buffer .= "\r\n";
$buffer .= join("", $this->body);
uv_write($this->client, $buffer, array($this->server, "onWrite"));
}
public function write($data, $callback = '')
{
if ($this->connection) {
$self = $this;
uv_write($this->connection, $data, function ($stream, $stat) use($callback) {
if ($stat == 0) {
//data is written out, execute the callback
if (is_callable($callback)) {
$callback();
}
}
});
}
}
/**
* Writes data through the socket
*
* @param $buffer
* @param callable $callback
* @return ClientInterface
*/
public function write($buffer, callable $callback = null)
{
$client = $this;
// ignore any queued writes if no longer running
if (false === $this->running) {
return $this;
}
\uv_write($this->connection, $buffer, function ($resource, $error) use($client, $buffer, $callback) {
if ($error) {
$client->emit(new Event('error', ['data' => $buffer]));
return;
}
if ($callback !== null) {
$callback($client);
}
});
return $this;
}
<?php
$pipe = uv_pipe_init(uv_default_loop(), 0);
uv_pipe_open($pipe, 1);
//uv_pipe_bind($pipe,"/tmp/hoge.sock");
uv_write($pipe, "Hello", function ($b, $s) {
echo 1;
uv_close($b);
});
uv_run();
<?php
$tcp = uv_tcp_init();
uv_tcp_bind($tcp, uv_ip4_addr('0.0.0.0', 9999));
uv_listen($tcp, 100, function ($server) {
$client = uv_tcp_init();
uv_accept($server, $client);
var_dump(uv_tcp_getsockname($server));
uv_read_start($client, function ($socket, $nread, $buffer) use($server) {
var_dump($buffer);
uv_close($socket);
uv_close($server);
});
});
$c = uv_tcp_init();
uv_tcp_connect($c, uv_ip4_addr('0.0.0.0', 9999), function ($client, $stat) {
if ($stat == 0) {
uv_write($client, "Hello", function ($socket, $stat) {
uv_close($socket);
});
}
});
uv_run();
unset($clients[(int) $client]);
});
});
return;
} else {
if ($nread == 0) {
if (uv_last_error() == UV::EOF) {
uv_shutdown($client, function ($client) use(&$parsers, &$clients) {
uv_close($client, function ($client) use(&$parsers, &$clients) {
unset($parsers[(int) $client]);
unset($clients[(int) $client]);
});
});
return;
}
} else {
$result = array();
if (uv_http_parser_execute($parsers[(int) $client], $buffer, $result)) {
$response = "HTTP/1.1 200 OK\r\n\r\nHello World";
uv_write($client, $response, function ($client) use(&$parsers, &$clients) {
uv_close($client, function ($client) use(&$parsers, &$clients) {
unset($parsers[(int) $client]);
unset($clients[(int) $client]);
});
});
}
}
}
});
});
uv_run(uv_default_loop());
break;
case ProtocolCached_Request_RequestType::GET:
$result = $store->get($request->getGet()->getKey());
break;
}
} catch (ProtocolBuffers\InvalidProtocoBufferException $e) {
echo $e->getMessage();
}
if ($result) {
$response = new ProtocolCached_Response();
$response->setType(ProtocolCached_Response_ResponseType::GET);
$payload = new ProtocolCached_GetResponse();
$payload->setValue($result);
$response->setGet($payload);
uv_write($socket, $response->serializeToString(), function ($socket, $stat) {
echo "# Connection closed\n";
uv_close($socket);
});
} else {
echo "# Connection closed\n";
uv_close($socket);
}
});
});
$timer = uv_timer_init();
$stat = array();
$stat['begin'] = memory_get_usage();
uv_timer_start($timer, 10, 1000, function ($stat, $timer) use(&$stat, $store) {
$stat["current"] = memory_get_usage();
printf("# memory: %d\n", $stat["current"] - $stat['begin']);
printf("# collection size: %d\n", $store->count());
});
$uv = uv_ares_init_options(uv_default_loop(), array("servers" => array("8.8.8.8"), "port" => 53), null);
ares_gethostbyname($uv, $domain, AF_INET, function ($name, $addr) use($path, $host) {
$a = array_shift($addr);
$address = uv_ip4_addr($a, "80");
$tcp = uv_tcp_init();
uv_tcp_connect($tcp, $address, function ($client, $stat) use($path, $host) {
var_dump(uv_tcp_getpeername($client));
$request = <<<EOF
GET {$path} HTTP/1.0
Host: {$host}
EOF;
echo $request;
var_dump($client);
uv_write($client, $request, function ($client, $stat) {
echo "write";
if ($stat == 0) {
uv_read_start($client, function ($client, $nread, $buffer) {
echo "\n1\n";
//var_dump($buffer);
uv_close($client);
});
} else {
echo 2;
uv_close($client);
}
});
});
});
uv_run();
$c = uv_tcp_init();
uv_tcp_connect6($c, uv_ip6_addr('::1', 9999), function ($client, $stat) {
if ($stat == 0) {
$request = new ProtocolCached_Request();
$type = getRequestType($_SERVER['argv'][1]);
$request->setType($type);
if ($type == ProtocolCached_Request_RequestType::SET) {
$set = new ProtocolCached_SetRequest();
$set->setKey($_SERVER['argv'][2]);
$set->setValue($_SERVER['argv'][3]);
$request->setSet($set);
} else {
if ($type == ProtocolCached_Request_RequestType::GET) {
$set = new ProtocolCached_GetRequest();
$set->setKey($_SERVER['argv'][2]);
$request->setGet($set);
}
}
uv_write($client, $request->serializeToString(), function ($socket, $stat) use($type) {
if ($type == ProtocolCached_Request_RequestType::GET) {
uv_read_start($socket, function ($socket, $nread, $buffer) use($type) {
var_dump(ProtocolCached_Response::parseFromString($buffer));
uv_close($socket);
});
} else {
uv_close($socket);
}
});
}
});
uv_run();
<?php
define("PIPE_PATH", dirname(__FILE__) . "/pipe_test.sock");
@unlink(PIPE_PATH);
$a = uv_pipe_init(uv_default_loop(), 0);
$ret = uv_pipe_bind($a, PIPE_PATH);
uv_listen($a, 8192, function ($stream) {
$pipe = uv_pipe_init(uv_default_loop(), 0);
uv_accept($stream, $pipe);
uv_read_start($pipe, function ($pipe, $nread, $buffer) use($stream) {
echo $buffer;
uv_read_stop($pipe);
uv_close($stream, function () {
@unlink(PIPE_PATH);
});
});
});
$b = uv_pipe_init(uv_default_loop(), 0);
uv_pipe_connect($b, PIPE_PATH, function ($a, $b) {
uv_write($b, "Hello", function ($stream, $stat) {
uv_close($stream);
});
});
uv_run();
exit;
<?php
$tcp = uv_tcp_init();
uv_tcp_bind($tcp, uv_ip4_addr('0.0.0.0', 79));
$users = array(array("username" => "chobie", "name" => "Shuhei Tanuma", "twitter" => "chobi_e"));
function pad($str)
{
return str_pad($str, 20, ' ', STR_PAD_RIGHT);
}
uv_listen($tcp, 100, function ($server) use($users) {
$client = uv_tcp_init();
uv_accept($server, $client);
uv_read_start($client, function ($socket, $nread, $buffer) use($users) {
$buffer = str_replace("/W", "", $buffer);
if ($buffer == "\r\n") {
$data = "";
$keys = array("Login", "Name", "Twitter");
$data .= join("", array_map("pad", $keys)) . "\r\n";
foreach ($users as $user) {
$data .= join("", array_map("pad", array_values($user))) . "\r\n";
}
uv_write($socket, $data, function ($client, $stat) {
uv_close($client);
});
} else {
var_dump($buffer);
uv_close($socket);
}
});
});
uv_run();
