onReadable() public static method

Warning: Closing resources locally, e.g. with fclose, might not invoke the callback. Be sure to cancel the watcher when closing the resource locally. Drivers MAY choose to notify the user if there are watchers on invalid resources, but are not required to, due to the high performance impact. Watchers on closed resources are therefore undefined behavior. Multiple watchers on the same stream MAY be executed in any order.
public static onReadable ( resource $stream, callable $callback, mixed $data = null ) : string
$stream resource The stream to monitor.
$callback callable
$data mixed Arbitrary data given to the callback function as the `$data` parameter.
return string An unique identifier that can be used to cancel, enable or disable the watcher.
Exemplo n.º 1
0
 public function read(int $length = 8192) : Awaitable
 {
     if (!$this->readerEnabled) {
         $len = \strlen($this->readBuffer);
         try {
             $chunk = $this->fillReadBuffer($len, $length);
         } catch (\Throwable $e) {
             return new Failure($e);
         }
         if ($chunk === null) {
             return new Success(null);
         }
         if ($chunk !== $this) {
             if ($len > $length) {
                 $this->readBuffer = \substr($chunk, $length);
                 return new Success(\substr($chunk, 0, $length));
             }
             $this->readBuffer = '';
             return new Success($chunk);
         }
         $this->readerEnabled = true;
         if ($this->pendingReads === null) {
             $this->pendingReads = new \SplQueue();
         }
         if ($this->readWatcher === null) {
             $this->readWatcher = Loop::onReadable($this->socket, $this->createReadWatcher());
         } else {
             try {
                 Loop::enable($this->readWatcher);
             } catch (InvalidWatcherException $e) {
                 $this->readWatcher = Loop::onReadable($this->socket, $this->createReadWatcher());
             }
         }
     }
     $this->pendingReads->enqueue($read = new PendingRead($length, function () {
         foreach ($this->pendingReads as $read) {
             if (!$read->disabled) {
                 return;
             }
         }
         $this->readerEnabled = false;
         Loop::disable($this->readWatcher);
     }));
     return $read;
 }
Exemplo n.º 2
0
 public function __construct($stream, float $timeout = 0)
 {
     if (!\is_resource($stream)) {
         throw new \InvalidArgumentException(\sprintf('Expecting stream resource, given %s', \is_object($stream) ? \get_class($stream) : \gettype($stream)));
     }
     $this->watcher = Loop::onReadable($stream, function () use($stream) {
         if ($this->state === self::PENDING) {
             Loop::cancel($this->watcher);
             if ($this->timer !== null) {
                 Loop::cancel($this->timer);
             }
             $this->resolve($stream);
         }
     });
     if ($timeout > 0) {
         $this->timer = Loop::delay($timeout * 1000, function () use($timeout) {
             if ($this->state === self::PENDING) {
                 Loop::cancel($this->watcher);
                 $this->fail(new TimeoutException(\sprintf('Await Read timed out after %.3f seconds', $timeout)));
             }
         });
     }
 }
Exemplo n.º 3
0
 public function handleCallback(string $func, ...$args) : Awaitable
 {
     $request = null;
     $defer = new Deferred(function () use(&$request) {
         if (\is_resource($request)) {
             \eio_cancel($request);
         }
     });
     $defer->when(function () {
         $this->pending--;
         if (!$this->pending) {
             Loop::disable($this->watcherId);
         }
     });
     for ($len = \count($args), $i = 0; $i < $len; $i++) {
         if ($args[$i] instanceof \Closure) {
             $callback = $args[$i];
             $args[$i] = function (...$args) use($defer, $callback) {
                 try {
                     $result = $callback(...$args);
                 } catch (\Throwable $e) {
                     return $defer->fail($e);
                 }
                 if ($result instanceof \Generator) {
                     $defer->resolve(new Coroutine($result));
                 } else {
                     $defer->resolve($result);
                 }
             };
             break;
         }
     }
     if (!isset($callback)) {
         throw new \InvalidArgumentException('Missing callback argument');
     }
     if (!$this->pending) {
         if ($this->watcherId === null) {
             $this->watcherId = Loop::onReadable(self::$eio, self::$callback);
         } else {
             Loop::enable($this->watcherId);
         }
     }
     $this->pending++;
     try {
         $request = $func(...$args);
     } catch (\Throwable $e) {
         $this->pending--;
         if (!$this->pending) {
             Loop::disable($this->watcherId);
         }
         return new Failure($e);
     }
     return $defer;
 }