/** * @param int $count * @return void */ public function produceNext($count = 1) { if ($this->completed) { return; } for ($i = 0; $i < $count; $i++) { if (!$this->isIteratorValid()) { $this->completed = true; $this->obs->onCompleted(); return; } $this->obs->onNext($this->iterator->current()); $this->iterator->next(); } }
/** * @param $sourceDir * @param $targetDir * @param $isDryRun * @return Observable\ConnectableObservable */ public function execute($sourceDir, $targetDir, $isDryRun) { $files = Observable::fromIterator($this->filesystem->ls($sourceDir)); $filesWithDate = $this->fileWithDateRepository->extractDateFrom($files)->publish(); $symlinkCommands = $this->symlinkCommandRepository->createSymlinkCommands($filesWithDate, new Path($targetDir)); $summary = $this->summaryRepository->summarize($filesWithDate); $symlinkCommands->merge($summary)->subscribe($this->output); if (!$isDryRun) { $symlinkCommands->subscribeCallback(function (SymlinkCommand $cmd) { $this->output->onNext("write file"); $this->linkRepository->createLink($cmd->getSource(), $cmd->getTarget()); }); } $filesWithDate->connect(); }
/** * */ public function onCompleted() { if ($this->valueSet) { parent::onNext($this->value); } parent::onCompleted(); }
/** * @inheritDoc */ public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null) { $outerDisposable = new SerialDisposable(); $this->disposable->add($outerDisposable); $subscribe = function () use($outerDisposable, $observable, $observer, $scheduler, &$subscribe) { $this->sourceComplete = false; $outerSubscription = $observable->subscribe(new CallbackObserver([$observer, "onNext"], [$observer, "onError"], function () use($observer, &$subscribe, $outerDisposable) { $this->sourceComplete = true; if (!$this->repeat) { $observer->onCompleted(); return; } $outerDisposable->setDisposable(new EmptyDisposable()); $this->completions->onNext(++$this->count); }), $scheduler); $outerDisposable->setDisposable($outerSubscription); }; $notifierDisposable = $this->notifier->subscribe(new CallbackObserver(function () use(&$subscribe, $scheduler) { $subscribe(); }, function ($ex) use($observer) { $this->repeat = false; $observer->onError($ex); }, function () use($observer) { $this->repeat = false; if ($this->sourceComplete) { $observer->onCompleted(); } }), $scheduler); $this->disposable->add($notifierDisposable); try { $handled = call_user_func($this->notificationHandler, $this->completions->asObservable()); $handledDisposable = $handled->subscribe($this->notifier, $scheduler); $this->disposable->add($handledDisposable); } catch (\Exception $e) { $observer->onError($e); return new EmptyDisposable(); } $subscribe(); return $this->disposable; }
/** * @inheritDoc */ public function __invoke(ObservableInterface $observable, ObserverInterface $observer, SchedulerInterface $scheduler = null) { $errors = new Subject(); $disposable = new CompositeDisposable(); $sourceDisposable = new EmptyDisposable(); $innerCompleted = false; $sourceError = false; try { $when = call_user_func($this->notificationHandler, $errors->asObservable()); } catch (\Exception $e) { $observer->onError($e); return; } $subscribeToSource = function () use($observer, $disposable, $observable, &$sourceError, $errors, &$sourceDisposable, $scheduler, &$innerCompleted) { $sourceError = false; $sourceDisposable = $observable->subscribe(new CallbackObserver([$observer, 'onNext'], function ($err) use(&$sourceError, $errors, $disposable, &$sourceDisposable, &$innerCompleted, $observer) { $sourceError = true; $disposable->remove($sourceDisposable); $sourceDisposable->dispose(); if ($innerCompleted) { $observer->onCompleted(); return; } $errors->onNext($err); }, [$observer, 'onCompleted']), $scheduler); $disposable->add($sourceDisposable); }; $whenDisposable = $when->subscribe(new CallbackObserver(function ($x) use($subscribeToSource, &$sourceError) { if ($sourceError) { $sourceError = false; $subscribeToSource(); } }, [$observer, 'onError'], function () use(&$innerCompleted, &$sourceError, $observer) { $innerCompleted = true; if ($sourceError) { $observer->onCompleted(); } }), $scheduler); $disposable->add($whenDisposable); $subscribeToSource(); return $disposable; }
public function onNext($value) { $this->value = $value; return parent::onNext($value); }
/** * @test * @expectedException RuntimeException */ public function it_passes_on_next_if_disposed() { $subject = new Subject(); $value = 42; $subject->dispose(); $subject->onNext($value); }
/** * ConnectionSubject constructor. * @param ObservableInterface $rawDataIn * @param ObserverInterface $rawDataOut * @param bool $mask * @param bool $useMessageObject * @param string $subProtocol * @param RequestInterface $request * @param ResponseInterface $response */ public function __construct(ObservableInterface $rawDataIn, ObserverInterface $rawDataOut, $mask = false, $useMessageObject = false, $subProtocol = "", RequestInterface $request, ResponseInterface $response) { $this->request = $request; $this->response = $response; $this->rawDataIn = new AnonymousObservable(function ($observer) use($rawDataIn) { return $rawDataIn->subscribe($observer); }); $this->rawDataOut = $rawDataOut; $this->mask = $mask; $this->subProtocol = $subProtocol; // This can be used instead of the subjecg when this issue is addressed: // https://github.com/asm89/Rx.PHP/issues/20 // Actually - using the subject is better so that the framing doesn't get done for every // subscriber. //$frames = $this->rawDataIn // ->lift(new WebsocketFrameOperator()); $frames = new Subject(); $this->rawDataIn->lift(function () { return new WebsocketFrameOperator(); })->subscribe(new CallbackObserver([$frames, "onNext"], function ($error) use($frames) { $close = $this->createCloseFrame(); if ($error instanceof WebsocketErrorException) { $close = $this->createCloseFrame($error->getCloseCode()); } $this->sendFrame($close); $this->rawDataOut->onCompleted(); // TODO: Should this error through to frame observers? $frames->onCompleted(); }, function () use($frames) { $this->rawDataOut->onCompleted(); $frames->onCompleted(); })); $this->controlFrames = $frames->filter(function (Frame $frame) { return $frame->getOpcode() > 2; }); // default ping handler (ping received from far end $this->controlFrames->filter(function (Frame $frame) { return $frame->getOpcode() === $frame::OP_PING; })->subscribe(new CallbackObserver(function (Frame $frame) { $pong = new Frame($frame->getPayload(), true, Frame::OP_PONG); $this->sendFrame($pong); })); $frames->filter(function (Frame $frame) { return $frame->getOpcode() < 3; })->lift(function () use($mask, $useMessageObject) { return new WebsocketMessageOperator($mask, $useMessageObject); })->subscribe(new CallbackObserver(function ($x) { parent::onNext($x); }, function ($x) { parent::onError($x); }, function () { parent::onCompleted(); })); $this->subProtocol = $subProtocol; }
private function startConnection() { $loop = \EventLoop\getLoop(); $dnsResolverFactory = new Factory(); $dnsResolver = $dnsResolverFactory->createCached('8.8.8.8', $loop); $factory = new \React\HttpClient\Factory(); $client = $factory->create($loop, $dnsResolver); $cNegotiator = new ClientNegotiator($this->url, $this->subProtocols); $headers = $cNegotiator->getRequest()->getHeaders(); $flatHeaders = []; foreach ($headers as $k => $v) { $flatHeaders[$k] = $v[0]; } $request = $client->request("GET", $this->url, $flatHeaders, '1.1'); $request->on('response', function (Response $response, Request $request) use($cNegotiator) { if ($response->getCode() !== 101) { throw new \Exception("Unexpected response code " . $response->getCode()); } // TODO: Should validate response //$cNegotiator->validateResponse($response); $subprotoHeader = ""; $psr7Response = new \GuzzleHttp\Psr7\Response($response->getCode(), $response->getHeaders(), null, $response->getVersion()); if (count($psr7Response->getHeader('Sec-WebSocket-Protocol')) == 1) { $subprotoHeader = $psr7Response->getHeader('Sec-WebSocket-Protocol')[0]; } parent::onNext(new MessageSubject(new AnonymousObservable(function (ObserverInterface $observer) use($response) { $response->on('data', function ($data) use($observer) { $observer->onNext($data); }); $response->on('error', function ($e) use($observer) { $observer->onError($e); }); $response->on('close', function () use($observer) { $observer->onCompleted(); }); $response->on('end', function () use($observer) { $observer->onCompleted(); // complete the parent observer - we only do 1 connection parent::onCompleted(); }); return new CallbackDisposable(function () use($response) { // commented this out because disposal was causing the other // end (the request) to close also - which causes the pending messages // to get tossed //$response->close(); }); }), new CallbackObserver(function ($x) use($request) { $request->write($x); }, function ($e) use($request) { $request->close(); }, function () use($request) { $request->end(); }), true, $this->useMessageObject, $subprotoHeader, $cNegotiator->getRequest(), $psr7Response)); }); $request->writeHead(); }
public function onNext($event) { parent::onNext($event); $this->notifyCompleted(); }