public function loadEtcResolvConf($filename) { if (!file_exists($filename)) { return When::reject(new \InvalidArgumentException("The filename for /etc/resolv.conf given does not exist: {$filename}")); } try { $deferred = new Deferred(); $fd = fopen($filename, 'r'); stream_set_blocking($fd, 0); $contents = ''; $stream = new Stream($fd, $this->loop); $stream->on('data', function ($data) use(&$contents) { $contents .= $data; }); $stream->on('end', function () use(&$contents, $deferred) { $deferred->resolve($contents); }); $stream->on('error', function ($error) use($deferred) { $deferred->reject($error); }); return $deferred->promise(); } catch (\Exception $e) { return When::reject($e); } }
public function __construct(Stream $stream, ParserInterface $parser = null, SerializerInterface $serializer = null) { if ($parser === null || $serializer === null) { $factory = new ProtocolFactory(); if ($parser === null) { $parser = $factory->createResponseParser(); } if ($serializer === null) { $serializer = $factory->createSerializer(); } } $that = $this; $stream->on('data', function ($chunk) use($parser, $that) { try { $models = $parser->pushIncoming($chunk); } catch (ParserException $error) { $that->emit('error', array($error)); $that->close(); return; } foreach ($models as $data) { try { $that->handleMessage($data); } catch (UnderflowException $error) { $that->emit('error', array($error)); $that->close(); return; } } }); $stream->on('close', array($this, 'close')); $this->stream = $stream; $this->parser = $parser; $this->serializer = $serializer; }
public function job($parameters) { $pretty = $this->getQueryParameter("pretty", false); if ($pretty) { $pretty = true; } $name = $parameters['name']; $method = strtolower($this->request->getMethod()); $job = $this->worker->job->getJob($name); if (!$job) { $this->response->writeHead(404, array('Content-Type' => 'text/plain')); $this->response->end("Not found\n"); $this->server->outputAccessLog($this->request, 404); return; } if ($method == 'get') { $buffer = null; $self = $this; $response = $this->response; $request = $this->request; $stream = new Stream(fopen($job->getInfoFilePath(), 'r'), $this->worker->eventLoop); $stream->on('data', function ($data, $stream) use(&$buffer) { $buffer .= $data; }); $stream->on('end', function ($stream) use($job, $response, $request, $self, &$buffer, $pretty) { $info = json_decode($buffer, true); $number = 0; if (isset($info["runtime_jobs"])) { $number = count($info["runtime_jobs"]); } $contents = []; $contents['number_of_running_jobs'] = $number; $response->writeHead(200, array('Content-Type' => 'application/json; charset=utf-8')); if ($pretty) { $output = json_encode($contents, JSON_PRETTY_PRINT); } else { $output = json_encode($contents); } $response->end($output); $self->server->outputAccessLog($request, 200); }); } elseif ($method == 'post') { $query = $this->request->getQuery(); $this->worker->job->executeJob($job, true, $query); $contents = ["status" => "OK"]; $this->response->writeHead(200, array('Content-Type' => 'application/json; charset=utf-8')); if ($pretty) { $output = json_encode($contents, JSON_PRETTY_PRINT); } else { $output = json_encode($contents); } $this->response->end($output); $this->server->outputAccessLog($this->request, 200); } else { $this->response->writeHead(400, array('Content-Type' => 'text/plain')); $this->response->end("Bad Request\n"); $this->server->outputAccessLog($this->request, 400); } }
public function __construct(Stream $stream, $protocol, $version, $code, $reasonPhrase, $headers) { $this->stream = $stream; $this->protocol = $protocol; $this->version = $version; $this->code = $code; $this->reasonPhrase = $reasonPhrase; $this->headers = $headers; $stream->on('data', array($this, 'handleData')); $stream->on('error', array($this, 'handleError')); $stream->on('end', array($this, 'handleEnd')); }
/** * @dataProvider loopProvider */ public function testBufferReadsLargeChunks($condition, $loopFactory) { if (true !== $condition()) { return $this->markTestSkipped('Loop implementation not available'); } $loop = $loopFactory(); list($sockA, $sockB) = stream_socket_pair(STREAM_PF_UNIX, STREAM_SOCK_STREAM, 0); $streamA = new Stream($sockA, $loop); $streamB = new Stream($sockB, $loop); $bufferSize = 4096; $streamA->bufferSize = $bufferSize; $streamB->bufferSize = $bufferSize; $testString = str_repeat("*", $streamA->bufferSize + 1); $buffer = ""; $streamB->on('data', function ($data, $streamB) use(&$buffer, &$testString) { $buffer .= $data; }); $streamA->write($testString); $loop->tick(); $loop->tick(); $loop->tick(); $streamA->close(); $streamB->close(); $this->assertEquals($testString, $buffer); }
/** * @param NetworkAddressInterface $remotePeer * @param ConnectionParams $params * @return \React\Promise\Promise|\React\Promise\PromiseInterface */ public function outboundHandshake(NetworkAddressInterface $remotePeer, ConnectionParams $params) { $deferred = new Deferred(); $awaitVersion = true; $this->stream->on('close', function () use(&$awaitVersion, $deferred) { if ($awaitVersion) { $awaitVersion = false; $deferred->reject('peer disconnected'); } }); $this->on(Message::VERSION, function (Peer $peer, Version $version) use($params) { $this->remoteVersion = $version; $this->verack(); }); $this->on(Message::VERACK, function () use($deferred) { if (false === $this->exchangedVersion) { $this->exchangedVersion = true; $this->emit('ready', [$this]); $deferred->resolve($this); } }); $this->peerAddress = $remotePeer; $this->localVersion = $version = $params->produceVersion($this->msgs, $remotePeer); $this->connectionParams = $params; $this->send($version); return $deferred->promise(); }
public function subscribe(ObserverInterface $observer, $scheduler = null) { $this->stream->on('data', function ($data) use($observer) { $observer->onNext($data); }); $this->stream->on('error', function ($error) use($observer) { $ex = $error instanceof \Exception ? $error : new \Exception($error); $observer->onError($ex); }); $this->stream->on('close', function () use($observer) { $observer->onCompleted(); }); $disposable = parent::subscribe($observer, $scheduler); return new BinaryDisposable($disposable, new CallbackDisposable(function () use($observer) { $this->removeObserver($observer); $this->dispose(); })); }
public function __construct(LoopInterface $loop) { $bspcProcess = proc_open('pactl subscribe', [['pipe', 'r'], ['pipe', 'w']], $pipes); $bspcStdout = new Stream($pipes[1], $loop); $bspcStdout->on('data', [$this, 'onUpdate']); $loop->addTimer(0, function () { $this->queryData(); }); }
public function __construct(LoopInterface $loop, SpawnerInterface $spawner, $id, $cmd, $args, $onData, $onExit) { $this->id = $id; $this->loop = $loop; $this->process = new Process($spawner->spawn($cmd, $args)); $this->process->on('exit', function ($exitCode, $termSignal) use($onExit) { call_user_func($onExit, $exitCode, $termSignal); }); $this->process->start($loop); $this->out = $this->process->stdout; $this->in = $this->process->stdin; $this->err = $this->process->stderr; $this->out->on('data', function ($data) use($onData) { call_user_func($onData, $data); }); $this->err->on('data', function ($data) use($onData) { call_user_func($onData, $data); }); }
public function handleRequest($request, $response, $connection) { $path = $this->getPath($request); $fullPath = $this->docroot . DIRECTORY_SEPARATOR . $path; echo "Loading static file: {$path}" . PHP_EOL; // if(isset($this->fileCache[$path])) { // echo "cache hit for: $path" . PHP_EOL; // $response->setBody($this->fileCache[$path]); // return $this->send($connection, $response); // } $fd = fopen($fullPath, "r"); /* @note LibEvent doesn't handle file reads asynchronously (non-blocking) */ stream_set_blocking($fd, 0); $stream = new Stream($fd, $this->loop); $this->buffer[$path] = ''; $stream->on('data', Partial\bind([$this, 'onData'], $path)); $stream->on('close', Partial\bind([$this, 'onClose'], $path, $response, $connection)); $stream->on('error', Partial\bind([$this, 'onError'], $path, $response, $connection)); }
public function __construct(Stream $stream, LoopInterface $loop) { $this->stream = $stream->stream; $this->decorating = $stream; $this->loop = $loop; $stream->on('error', function ($error) { $this->emit('error', [$error, $this]); }); $stream->on('end', function () { $this->emit('end', [$this]); }); $stream->on('close', function () { $this->emit('close', [$this]); }); $stream->on('drain', function () { $this->emit('drain', [$this]); }); $stream->pause(); $this->resume(); }
public function probe(Stream $stream, $compression = false, $encryption = false) { $magic = Protocol::MAGIC; if ($compression) { $magic |= Protocol::FEATURE_COMPRESSION; } if ($encryption) { $magic |= Protocol::FEATURE_ENCRYPTION; } $binary = $this->binary; $stream->write($binary->writeUInt32($magic)); // list of supported protocol types (in order of preference) $types = array(Protocol::TYPE_DATASTREAM, Protocol::TYPE_LEGACY); // last item should get an END marker $last = array_pop($types); $types[] = $last | Protocol::TYPELIST_END; foreach ($types as $type) { $stream->write($binary->writeUInt32($type)); } $deferred = new Deferred(function ($resolve, $reject) use($stream) { $reject(new \RuntimeException('Cancelled')); }); $buffer = ''; $fn = function ($data) use(&$buffer, &$fn, $stream, $deferred, $binary) { $buffer .= $data; if (isset($buffer[4])) { $stream->removeListener('data', $fn); $deferred->reject(new \UnexpectedValueException('Expected 4 bytes response, received more data, is this a quassel core?', Prober::ERROR_PROTOCOL)); return; } if (isset($buffer[3])) { $stream->removeListener('data', $fn); $deferred->resolve($binary->readUInt32($buffer)); } }; $stream->on('data', $fn); $stream->on('close', function () use($deferred) { $deferred->reject(new \RuntimeException('Stream closed, does this (old?) server support probing?', Prober::ERROR_CLOSED)); }); return $deferred->promise(); }
/** * @param LoopInterface $loop * @throws \LogicException */ public function start(LoopInterface $loop) { $this->input = new Stream(STDIN, $loop); $this->input->on('error', [$this, 'handleError']); $this->input->on('data', [$this, 'handleInput']); $this->output = new ConsoleOutput($loop); $this->output->on('error', [$this, 'handleError']); if ($this->isRunning()) { throw new \LogicException('The shell is already running.'); } $this->isRunning = true; $this->application->setAutoExit(false); $this->application->setCatchExceptions(true); $this->on('data', function ($command) { $ret = $this->application->run(new StringInput($command), $this->output); if (0 !== $ret) { $this->output->writeln(sprintf('<error>The command terminated with an error status (%s)</error>', $ret)); } }); $this->on('output', [$this, 'write']); $this->emit('running', [$this]); }
/** * @param Stream $stream * @return PromiseInterface */ public function handleInit(Stream $stream) { $this->stream = $stream; return new Promise(function (callable $fulfill, callable $reject) { $this->stream->once('data', function ($data) use($fulfill, $reject) { if (preg_match('/^ok\\b/i', $data)) { $this->stream->on('data', [$this, 'handleData']); $this->stream->on('error', [$this, 'handleError']); call_user_func($fulfill); } else { call_user_func($reject, trim($data)); } }); }); }
/** * Initializes basic peer functionality - used in server and client contexts * * @return $this */ private function setupConnection() { $this->stream->on('data', function ($data) { $this->buffer .= $data; $this->emit('data'); }); $this->stream->on('close', function () { $this->close(); }); $this->on('data', function () { $this->onData(); }); $this->on('msg', function (Peer $peer, NetworkMessage $msg) { $this->emit($msg->getCommand(), [$peer, $msg->getPayload()]); }); return $this; }
/** * */ public function on() { $client = stream_socket_client('tcp://' . $this->address . ':' . $this->port); $buffer = $this->buffer; $stock = $this->stock; $conn = new Stream($client, $this->loop); $conn->on('data', function ($data) use($conn, $buffer, $stock) { $buffer->setCache($data); if (strspn($buffer->getCache(), 'close')) { $conn->close(); exit; } if (strpos($buffer->getCache(), PHP_EOL) !== false) { echo $data; } $stock->stockize($buffer->getCache()); }); }
public static function postInstall() { Config::makeBinDirectory(); $loop = Factory::create(); $file = Config::getBinFile(); $url = 'https://yt-dl.org/downloads/latest/youtube-dl'; $readStream = fopen($url, 'r'); $writeStream = fopen($file, 'w'); stream_set_blocking($readStream, 0); stream_set_blocking($writeStream, 0); $read = new Stream($readStream, $loop); $write = new Stream($writeStream, $loop); $read->on('end', function () use($file) { chmod($file, 0777); echo "Finished downloading {$file}\n"; }); $read->pipe($write); $loop->run(); }
/** * Handle http request * * @param HttpRequestEvent $event */ public function onRequest(HttpRequestEvent $event) { $filePath = $event->getRequest()->getPath(); foreach ($this->application->getMetadata() as $name => $metadata) { /* @var $metadata \PhpCollection\Map */ if ($metadata->containsKey('assets')) { $assumedFilePath = $metadata->get('application_path')->get() . DIRECTORY_SEPARATOR . $metadata->get('assets')->get() . DIRECTORY_SEPARATOR . $filePath; $assumedFilePath = realpath($assumedFilePath); if (file_exists($assumedFilePath) && is_file($assumedFilePath)) { $event->stopPropagation(); $fileStream = new Stream(fopen($assumedFilePath, 'r'), $this->serverLoop); $event->getResponse()->getHeaders()->set('Content-Type', MimeTypeGuesser::getMimeType($assumedFilePath)); $event->getResponse()->dispatchHeaders(); $fileStream->pipe($event->getResponse()->getReactResponse()); $fileStream->on('end', 'gc_collect_cycles'); gc_collect_cycles(); } } } }
/** * Internal helper used to handle the communication with the SOCKS server * * @param Stream $stream * @param string $host * @param int $port * @return Promise Promise<stream, Exception> * @internal */ public function handleConnectedSocks(Stream $stream, $host, $port) { $deferred = new Deferred(function ($_, $reject) { $reject(new RuntimeException('Connection attempt cancelled while establishing socks session')); }); $reader = new StreamReader($stream); $stream->on('data', array($reader, 'write')); if ($this->protocolVersion === '5') { $promise = $this->handleSocks5($stream, $host, $port, $reader); } else { $promise = $this->handleSocks4($stream, $host, $port, $reader); } $promise->then(function () use($deferred, $stream) { $deferred->resolve($stream); }, function ($error) use($deferred) { $deferred->reject(new Exception('Unable to communicate...', 0, $error)); }); $deferred->promise()->then(function (Stream $stream) use($reader) { $stream->removeAllListeners('end'); $stream->removeListener('data', array($reader, 'write')); return $stream; }, function ($error) use($stream) { $stream->close(); return $error; }); $stream->on('end', function (Stream $stream) use($deferred) { $deferred->reject(new Exception('Premature end while establishing socks session')); }); return $deferred->promise(); }
public function __construct(LoopInterface $loop) { $bspcProcess = proc_open('bspc subscribe report', [['pipe', 'r'], ['pipe', 'w']], $pipes); $bspcStdout = new Stream($pipes[1], $loop); $bspcStdout->on('data', [$this, 'onUpdate']); }
public function onConnection(Stream $conn) { printf("Connected: %s\n", $conn->getRemoteAddress()); $conn->on('data', [$this, 'onData']); $conn->on('end', [$this, 'onEnd']); }
/** * @covers React\Stream\Stream::handleData */ public function testDataErrorShouldEmitErrorAndClose() { $stream = fopen('php://temp', 'r+'); // add a filter which returns an error when encountering an 'a' when reading Filter\append($stream, function ($chunk) { if (strpos($chunk, 'a') !== false) { throw new \Exception('Invalid'); } return $chunk; }, STREAM_FILTER_READ); $loop = $this->createLoopMock(); $conn = new Stream($stream, $loop); $conn->on('data', $this->expectCallableNever()); $conn->on('error', $this->expectCallableOnce()); $conn->on('close', $this->expectCallableOnce()); fwrite($stream, "foobar\n"); rewind($stream); $conn->handleData($stream); }
/** * @covers React\Stream\Stream::handleData */ public function testClosingStreamInDataEventShouldNotTriggerError() { $stream = fopen('php://temp', 'r+'); $loop = $this->createLoopMock(); $conn = new Stream($stream, $loop); $conn->on(Event::DATA, function ($data, $stream) { $stream->close(); }); fwrite($stream, "foobar\n"); rewind($stream); $conn->handleData($stream); }
/** * @inheritDoc */ public function onData(\Closure $closure) { $this->reactStream->on('data', $closure); }
public function initAdapted(\GearmanJob $job) { $this->loop = Factory::create(); $this->read = new \React\Stream\Stream(STDIN, $this->loop); $this->read->bufferSize = 8192; $this->write = new \React\Stream\Stream(STDOUT, $this->loop); $this->write->bufferSize = 8192; $this->job = $job; //protect from repeated execution $initStart = false; $pmErrorDtoAlreadySent = false; /** * Receive sockets params json from PM to set it into performer */ $this->read->on('data', function ($data) use($initStart, $pmErrorDtoAlreadySent) { if (!is_array($this->pmWorkerDta)) { $this->pmWorkerDta = @json_decode($data, true); if ($this->pmWorkerDta !== false && is_array($this->pmWorkerDta)) { if ($initStart === false) { $initStart = true; try { $this->initBasicParams(); $this->adaptedService->getTerminatorPauseStander()->setPublisherPmSocketAddress($this->pmWorkerDta[DataTransferConstants::PUBLISHER_PM]); $this->adaptedService->getTerminatorPauseStander()->setUSleepTime(5000000); $performerSocketParams = new PerformerSocketsParamsDto(); $performerSocketParams->setRequestPulsarRsSocketAddress($this->pmWorkerDta[DataTransferConstants::REQUEST_PULSAR_RS]); $performerSocketParams->setPublisherPulsarSocketAddress($this->pmWorkerDta[DataTransferConstants::PUBLISHER_PULSAR]); $performerSocketParams->setPushPulsarSocketAddress($this->pmWorkerDta[DataTransferConstants::PUSH_PULSAR]); $this->adaptedService->getZmqPerformer()->setSocketsParams($performerSocketParams); $this->adaptedService->getZmqPerformer()->setLogger($this->logger); $this->adaptedService->serviceExec(); $this->adaptedService->getExecutionDto()->setExecutionMessage($this->adaptedService->getParams()); $this->job->sendComplete(serialize($this->adaptedService->getExecutionDto())); $this->jobInfoWasSent = true; $this->logger->critical("Job complete was sent."); } catch (\Exception $e) { $errorMsg = "Adapter die in Exception with \$e: " . $e->getMessage() . "|params: " . serialize($this->adaptedService->getParams()); //. $e->getTraceAsString(); $this->logger->critical($errorMsg . " | " . serialize($this->pmWorkerDta)); $this->job->sendComplete(serialize(InspectionHelper::prepareErrorExecutionDto($this->adaptedService->getTaskId(), $errorMsg))); $this->jobInfoWasSent = true; $this->logger->critical("Job complete with exception was sent."); die; } $this->loop->nextTick(function () { $this->loop->stop(); }); } } else { if ($pmErrorDtoAlreadySent === false) { $pmErrorDtoAlreadySent = true; $pmErrorArr = []; $pmErrorArr[DataTransferConstants::ERROR_LEVEL] = ErrorsConstants::CRITICAL; $pmErrorArr[DataTransferConstants::ERROR_REASON] = PmErrorConstants::WORKER_NOT_RECEIVE_CORRECT_DTO; $pmErrorArr[DataTransferConstants::ERROR_ELEMENT] = $this->pmWorkerDta; //write to PM's allotted STDIN about critical error $this->write->write(json_encode($pmErrorArr)); $this->loop->nextTick(function () { $this->loop->stop(); }); } } } }); $timerIteration = 0; $this->loop->addPeriodicTimer(3, function (Timer $timer) use(&$timerIteration) { if ($this->pmWorkerDta === null) { if ($timerIteration > $this->maxTimerIteration) { $this->initBasicParams(); die; } $timerIteration++; } else { $timer->cancel(); } }); $this->loop->run(); if ($pmErrorDtoAlreadySent) { die; } }
/** * Connection constructor. * @param Stream $stream * @param RequestFactory $requestFactory */ public function __construct(Stream $stream, RequestFactory $requestFactory) { $this->factory = $requestFactory; $this->stream = $stream; $this->stream->on('data', [$this, 'onData']); }
protected function saveTo() { $saveTo = $this->options['sink']; $writeStream = fopen($saveTo, 'w'); stream_set_blocking($writeStream, 0); $saveToStream = new ReactStream($writeStream, $this->loop); $saveToStream->on('end', function () { $this->onEnd(); }); $this->httpResponse->pipe($saveToStream); }
/** * @dataProvider loopProvider */ public function testDoesNotWriteDataIfClientSideHasBeenClosed($condition, $loopFactory) { if (true !== $condition()) { return $this->markTestSkipped('Loop implementation not available'); } $loop = $loopFactory(); $server = stream_socket_server('tcp://localhost:0'); $client = stream_socket_client(stream_socket_get_name($server, false)); $peer = stream_socket_accept($server); $streamA = new Stream($peer, $loop); $streamB = new Stream($client, $loop); // end streamA without writing any data $streamA->pause(); $streamA->write('hello'); $streamA->on('close', $this->expectCallableOnce()); $streamB->on('data', $this->expectCallableNever()); $streamB->close(); $loop->run(); $streamA->close(); $streamB->close(); }
require __DIR__ . '/../vendor/autoload.php'; $loop = Factory::create(); if (function_exists('posix_isatty') && posix_isatty(STDIN)) { // Disable icanon (so we can fread each keypress) and echo (we'll do echoing here instead) shell_exec('stty -icanon -echo'); } // process control codes from STDIN $stdin = new Stream(STDIN, $loop); $parser = new ControlCodeParser($stdin); $stdout = new Stream(STDOUT, $loop); $stdout->pause(); // pass all c0 codes through to output $parser->on('c0', array($stdout, 'write')); // replace any color codes (SGR) with a random color $parser->on('csi', function ($code) use($stdout) { // we read any color code (SGR) on the input // assign a new random foreground and background color instead if (substr($code, -1) === 'm') { $code = "[" . mt_rand(30, 37) . ';' . mt_rand(40, 47) . "m"; } $stdout->write($code); }); // reset to default color at the end $stdin->on('close', function () use($stdout) { $stdout->write("[m"); }); // pass plain data to output $parser->pipe($stdout, array('end' => false)); // start with random color $stdin->emit('data', array("[m")); $loop->run();
/** * Processing one URL, opens pair of read-write streams and piping them * * @param AMQPClosure $closure A closure of message with another URL * @param EventLoop\LoopInterface $loop A loop, worker is run on * * @return bool Success flag * * @throws \Exception */ private function processURL(AMQPClosure $closure, EventLoop\LoopInterface $loop) { $readStream = @fopen($closure->get(), 'r'); if (!$readStream) { return $this->error($closure); } $tmpdir = \Bot::config('tmpdir'); if (!file_exists($tmpdir)) { if (!mkdir($tmpdir, 0777, true)) { throw new \Exception('Cannot create downloading dirname ' . $tmpdir); } } $fWritePath = $tmpdir . "/" . md5($closure->get()); $writeStream = fopen($fWritePath, 'w'); if (!$writeStream) { throw new \Exception('Cannot open downloading file ' . $fWritePath); } $this->files[$fWritePath] = true; $read = new Stream($readStream, $loop); $write = new Stream($writeStream, $loop); $write->on('end', function () use($closure, $fWritePath) { unset($this->files[$fWritePath]); $this->success($closure); }); $read->on('error', function () use($closure, $fWritePath) { unset($this->files[$fWritePath]); $this->error($closure); }); $read->pipe($write); }