mirror of
https://github.com/danog/amp.git
synced 2025-01-22 13:21:16 +01:00
remove examples
This commit is contained in:
Daniel Lowrey
parent
03f7b8305c
commit
c3298f104a
@ -1,43 +0,0 @@
|
||||
<?php
|
||||
|
||||
require __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
/**
|
||||
* Running the reactor gives control of program control to the Amp event loop. Once started,
|
||||
* the reactor will only stop under one of the following two conditions:
|
||||
*
|
||||
* (1) No scheduled events remain outstanding and no IO streams are registered for observation
|
||||
* (2) The event reactor is explicitly stopped using Amp\stop() or calling
|
||||
* Reactor::stop() on the running Reactor instance.
|
||||
*
|
||||
* The event reactor is our task scheduler. It controls program flow as long as it runs.
|
||||
*
|
||||
* This example uses Amp's global function API to interact with the event loop. As it really
|
||||
* never makes sense to have multiple event loop instances in a single-threaded application the
|
||||
* function API is useful for interacting with a statically restricted global loop.
|
||||
*/
|
||||
|
||||
define('RUN_TIME', 10);
|
||||
printf("Each line you type will be echoed back for the next %d seconds ...\n\n", RUN_TIME);
|
||||
|
||||
Amp\run(function($reactor) {
|
||||
// Set the STDIN stream to "non-blocking" mode
|
||||
stream_set_blocking(STDIN, false);
|
||||
|
||||
// Echo back the line each time there is readable data on STDIN
|
||||
$reactor->onReadable(STDIN, function() {
|
||||
if ($line = fgets(STDIN)) {
|
||||
echo "INPUT> ", $line, "\n";
|
||||
}
|
||||
});
|
||||
|
||||
// Countdown RUN_TIME seconds then end the event loop
|
||||
$secondsRemaining = RUN_TIME;
|
||||
$reactor->repeat(function() use (&$secondsRemaining) {
|
||||
if (--$secondsRemaining > 0) {
|
||||
echo "$secondsRemaining seconds to shutdown\n";
|
||||
} else {
|
||||
$reactor->stop(); // <-- explicitly stop the loop
|
||||
}
|
||||
}, $msInterval = 1000);
|
||||
});
|
||||
@ -1,31 +0,0 @@
|
||||
<?php
|
||||
|
||||
require __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
Amp\run(function($reactor) {
|
||||
$ticker = function() {
|
||||
$now = time();
|
||||
$vowel = ($now % 2) ? 'i' : 'o';
|
||||
echo "t{$vowel}ck ", $now, "\n";
|
||||
};
|
||||
|
||||
// Execute the specified callback ASAP in the next event loop iteration. There is no
|
||||
// need to clear an "immediately" watcher after execution. The Reactor will automatically
|
||||
// garbage collect resources associated with one-time events after they finish executing.
|
||||
$reactor->immediately($ticker);
|
||||
|
||||
// Execute every $msInterval milliseconds until the resulting $watcherId is canceled.
|
||||
// At some point in the future we need to cancel this watcher or our program will never end.
|
||||
$repeatingWatcherId = Amp\repeat($ticker, $msInterval = 1000);
|
||||
|
||||
// Five seconds from now let's cancel the repeating ticker we just registered
|
||||
$reactor->once(function() use ($repeatingWatcherId) {
|
||||
$reactor->cancel($repeatingWatcherId);
|
||||
echo "Cancelled repeating ticker\n";
|
||||
}, $msDelay = 5000);
|
||||
|
||||
// After about five seconds the program will exit on its own. Why? This happens because in
|
||||
// that time frame we will have cancelled the repeating watcher we registered using repeat()
|
||||
// and the two one-off events (immediately() + once()) are automatically garbage collected
|
||||
// by the Reactor after they execute.
|
||||
});
|
||||
@ -1,141 +0,0 @@
|
||||
<?php
|
||||
|
||||
require __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
date_default_timezone_set('UTC'); // F U Derick.
|
||||
define('SERVER_ADDRESS', '127.0.0.1:1337');
|
||||
|
||||
|
||||
/**
|
||||
* A simple struct to hold a client's state while it's connected to our server
|
||||
*/
|
||||
class Client {
|
||||
public $id;
|
||||
public $socket;
|
||||
public $readWatcher;
|
||||
public $writeWatcher;
|
||||
public $outputBuffer;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* A simple TCP server that broadcasts the current time once per 3 seconds to all connected clients
|
||||
*/
|
||||
class Server {
|
||||
private $reactor;
|
||||
private $clients = [];
|
||||
private $ioGranularity = 8192;
|
||||
|
||||
public function __construct(Amp\Reactor $reactor = null) {
|
||||
$this->reactor = $reactor ?: Amp\reactor();
|
||||
}
|
||||
|
||||
public function start($address) {
|
||||
if (!$server = @stream_socket_server($address, $errno, $errstr)) {
|
||||
throw new RuntimeException(
|
||||
sprintf('Failed binding server on %s; [%d] %s', $address, $errno, $errstr)
|
||||
);
|
||||
}
|
||||
|
||||
printf("Server socket listening on %s\n", $address);
|
||||
|
||||
stream_set_blocking($server, false);
|
||||
|
||||
$this->reactor->onReadable($server, function() use ($server) {
|
||||
$this->acceptClients($server);
|
||||
});
|
||||
|
||||
// Let's schedule a broadcast of the current time to all connected sockets every three seconds
|
||||
$this->reactor->repeat(function() {
|
||||
$this->broadcastTime();
|
||||
}, $msInterval = 3000);
|
||||
|
||||
// Release the hounds!
|
||||
$this->reactor->run();
|
||||
}
|
||||
|
||||
private function acceptClients($server) {
|
||||
while ($socket = @stream_socket_accept($server, $timeout=0, $name)) {
|
||||
$client = new Client;
|
||||
$client->id = (int) $socket;
|
||||
$client->socket = $socket;
|
||||
|
||||
// What to do when the client socket is readable
|
||||
$client->readWatcher = $this->reactor->onReadable($socket, function() use ($client) {
|
||||
$this->readFromClient($client);
|
||||
});
|
||||
|
||||
// What to do when the socket is writable
|
||||
$client->writeWatcher = $this->reactor->onWritable($socket, function() use ($client) {
|
||||
$this->writeToClient($client);
|
||||
});
|
||||
|
||||
// Buffer something to send to the client. The writability watcher we just enabled
|
||||
// above will take care of sending this data automatically.
|
||||
$client->outputBuffer = "--- Welcome to the example server! ---\n\n";
|
||||
|
||||
printf("Client socket accepted: %s\n", $name);
|
||||
|
||||
// Store the client using its integer ID
|
||||
$this->clients[$client->id] = $client;
|
||||
}
|
||||
}
|
||||
|
||||
private function broadcastTime() {
|
||||
$data = date('r') . "\n";
|
||||
foreach ($this->clients as $client) {
|
||||
$client->outputBuffer .= $data;
|
||||
$this->reactor->enable($client->writeWatcher);
|
||||
}
|
||||
}
|
||||
|
||||
private function readFromClient(Client $client) {
|
||||
$data = @fread($client->socket, $this->ioGranularity);
|
||||
|
||||
// This only happens on EOF. If the socket has died we need to unload it.
|
||||
if ($data == '' && $this->isSocketDead($client->socket)) {
|
||||
$this->unloadClient($client);
|
||||
} else {
|
||||
printf("Data received from client %d: %s\n", $client->id, $data);
|
||||
}
|
||||
}
|
||||
|
||||
private function isSocketDead($socket) {
|
||||
return (!is_resource($socket) || feof($socket));
|
||||
}
|
||||
|
||||
private function writeToClient(Client $client) {
|
||||
$bytesWritten = @fwrite($client->socket, $client->outputBuffer);
|
||||
|
||||
if ($bytesWritten === strlen($client->outputBuffer)) {
|
||||
// All data written. Disable the writability watcher. Sockets are essentially "always"
|
||||
// writable, so it's important to disable write watchers when you don't have any data
|
||||
// remaining to write. Otherwise you'll just hammer your CPU.
|
||||
$client->outputBuffer = '';
|
||||
$this->reactor->disable($client->writeWatcher);
|
||||
} elseif ($bytesWritten > 0) {
|
||||
// Data was partially written -- truncate the buffer
|
||||
$client->outputBuffer = substr($client->outputBuffer, $bytesWritten);
|
||||
} elseif ($this->isSocketDead($client->socket)) {
|
||||
// Otherwise the client is dead and we just unload it
|
||||
$this->unloadClient($client);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* We have to clean up after ourselves or we'll create memory leaks. Always be sure to cancel
|
||||
* any stream IO watchers or repeating timer events once they're no longer needed!
|
||||
*/
|
||||
private function unloadClient(Client $client) {
|
||||
$this->reactor->cancel($client->readWatcher);
|
||||
$this->reactor->cancel($client->writeWatcher);
|
||||
if (is_resource($client->socket)) {
|
||||
@fclose($client->socket);
|
||||
}
|
||||
unset($this->clients[$client->id]);
|
||||
|
||||
printf("Client %d disconnected\n", $client->id);
|
||||
}
|
||||
}
|
||||
|
||||
(new Server)->start(SERVER_ADDRESS);
|
||||
@ -1,29 +0,0 @@
|
||||
<?php
|
||||
|
||||
/**
|
||||
* Process signals are "watchable" events just like timers and stream IO
|
||||
* availability. SignalReactor::onSignal() returns a unique watcher ID that
|
||||
* may be disabled/enabled/canceled like any other watcher.
|
||||
*
|
||||
* The available signal number constants vary by operating system, but you
|
||||
* can see the possible signals in your PHP install with the following
|
||||
* snippet:
|
||||
*
|
||||
* <?php
|
||||
* // Any constant beginning with SIG* is an available signal
|
||||
* print_r((new ReflectionClass('UV'))->getConstants());
|
||||
*/
|
||||
require __DIR__ . '/../vendor/autoload.php';
|
||||
|
||||
(new Amp\UvReactor)->run(function(Amp\Reactor $reactor) {
|
||||
// Let's tick off output once per second so we can see activity.
|
||||
$reactor->repeat(function() {
|
||||
echo "tick: ", date('c'), "\n";
|
||||
}, $msInterval = 1000);
|
||||
|
||||
// What to do when a SIGINT signal is received
|
||||
$reactor->onSignal(UV::SIGINT, function() {
|
||||
echo "Caught SIGINT! exiting ...\n";
|
||||
exit;
|
||||
});
|
||||
});
|
||||
Loading…
x
Reference in New Issue
Block a user