├── LICENSE
├── README.md
├── composer.json
├── phpdoc.dist.xml
└── src
    ├── Concurrent
        ├── ConcurrentDriver.php
        ├── ConcurrentFile.php
        └── Internal
        │   ├── File.php
        │   └── FileTask.php
    ├── Driver.php
    ├── Eio
        ├── EioDriver.php
        ├── EioFile.php
        └── Internal
        │   └── EioPoll.php
    ├── Exception
        ├── Error.php
        ├── Exception.php
        ├── FileException.php
        └── Throwable.php
    ├── File.php
    └── functions.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Aaron Piotrowski
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Asynchronous File Access for Icicle
 2 | 
 3 | Asynchronous filesystem access that is *always* non-blocking, no extensions required.
 4 | 
 5 | This library is a component for [Icicle](https://github.com/icicleio/icicle), providing asynchronous filesystem functions and abstracting files as asynchronous [streams](https://github.com/icicleio/stream). Like other Icicle components, this library uses [Coroutines](//github.com/icicleio/icicle/wiki/Coroutines) built from [Awaitables](https://github.com/icicleio/icicle/wiki/Awaitables) and [Generators](http://www.php.net/manual/en/language.generators.overview.php) to make writing asynchronous code more like writing synchronous code.
 6 | 
 7 | [![Build Status](https://img.shields.io/travis/icicleio/filesystem/v1.x.svg?style=flat-square)](https://travis-ci.org/icicleio/filesystem)
 8 | [![Coverage Status](https://img.shields.io/coveralls/icicleio/filesystem/v1.x.svg?style=flat-square)](https://coveralls.io/r/icicleio/filesystem)
 9 | [![Semantic Version](https://img.shields.io/github/release/icicleio/filesystem.svg?style=flat-square)](http://semver.org)
10 | [![MIT License](https://img.shields.io/packagist/l/icicleio/filesystem.svg?style=flat-square)](LICENSE)
11 | [![@icicleio on Twitter](https://img.shields.io/badge/twitter-%40icicleio-5189c7.svg?style=flat-square)](https://twitter.com/icicleio)
12 | 
13 | #### Documentation and Support
14 | 
15 | - [Full API Documentation](https://icicle.io/docs)
16 | - [Official Twitter](https://twitter.com/icicleio)
17 | - [Gitter Chat](https://gitter.im/icicleio/icicle)
18 | 
19 | ##### Requirements
20 | 
21 | - PHP 5.5+ for v0.1.x branch (current stable) and v1.x branch (mirrors current stable)
22 | - PHP 7 for v2.0 branch (under development) supporting generator delegation and return expressions
23 | 
24 | ##### Installation
25 | 
26 | The recommended way to install is with the [Composer](http://getcomposer.org/) package manager. (See the [Composer installation guide](https://getcomposer.org/doc/00-intro.md) for information on installing and using Composer.)
27 | 
28 | Run the following command to use this library in your project: 
29 | 
30 | ```bash
31 | composer require icicleio/filesystem
32 | ```
33 | 
34 | You can also manually edit `composer.json` to add this library as a project requirement.
35 | 
36 | ```js
37 | // composer.json
38 | {
39 |     "require": {
40 |         "icicleio/filesystem": "^0.1"
41 |     }
42 | }
43 | ```
44 | 
45 | ##### Suggested
46 | 
47 | - [eio extension](http://php.net/manual/en/book.eio.php): Uses libeio to provide asynchronous file access (v1.2.6+ required).
48 | 
49 | #### Example
50 | 
51 | ```php
52 | #!/usr/bin/env php
53 | <?php
54 | 
55 | require __DIR__ . '/vendor/autoload.php';
56 | 
57 | use Icicle\Coroutine;
58 | use Icicle\File;
59 | use Icicle\Loop;
60 | 
61 | Coroutine\create(function () {
62 |     $path = __DIR__ . '/test.txt';
63 | 
64 |     // Create and open the file for reading and writing.
65 |     $file = (yield File\open($path, 'w+'));
66 | 
67 |     try {
68 |         // Write data to file.
69 |         $written = (yield $file->write('testing'));
70 |         
71 |         printf("Wrote %d bytes to file.\n", $written);
72 |         
73 |         // Seek to beginning of file.
74 |         yield $file->seek(0);
75 |         
76 |         // Read data from file.
77 |         $data = (yield $file->read());
78 |     } finally {
79 |         $file->close();
80 |     }
81 |     
82 |     printf("Read data from file: %s\n", $data);
83 |     
84 |     // Remove file.
85 |     yield File\unlink($path);
86 | })->done();
87 | 
88 | Loop\run();
89 | ```


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "icicleio/filesystem",
 3 |     "description": "Asynchronous filesystem component for Icicle.",
 4 |     "keywords": [
 5 |         "asynchronous",
 6 |         "async",
 7 |         "file",
 8 |         "filesystem"
 9 |     ],
10 |     "homepage": "http://icicle.io",
11 |     "license": "MIT",
12 |     "authors": [
13 |         {
14 |             "name": "Aaron Piotrowski",
15 |             "email": "aaron@icicle.io"
16 |         }
17 |     ],
18 |     "require": {
19 |         "icicleio/icicle": "^2.0",
20 |         "icicleio/stream": "^2.0",
21 |         "icicleio/concurrent": "^2.0"
22 |     },
23 |     "require-dev": {
24 |         "phpunit/phpunit": "^5.0"
25 |     },
26 |     "minimum-stability": "dev",
27 |     "suggest": {
28 |         "ext-eio": "Extension providing better performance for asynchronous file access. v1.2.6+ required."
29 |     },
30 |     "extra": {
31 |         "branch-alias": {
32 |             "dev-master": "2.0.x-dev"
33 |         }
34 |     },
35 |     "autoload": {
36 |         "psr-4": {
37 |             "Icicle\\File\\": "src"
38 |         },
39 |         "files": [
40 |             "src/functions.php"
41 |         ]
42 |     },
43 |     "autoload-dev": {
44 |         "psr-4": {
45 |             "Icicle\\Tests\\File\\": "tests"
46 |         }
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/phpdoc.dist.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpdoc>
 3 |     <title>Icicle</title>
 4 |     <parser>
 5 |         <target>build/docs</target>
 6 |         <encoding>utf8</encoding>
 7 |     </parser>
 8 |     <transformer>
 9 |         <target>build/docs</target>
10 |     </transformer>
11 |     <logging>
12 |         <level>warn</level>
13 |         <paths>
14 |             <default>build/log/docs/{DATE}.log</default>
15 |         </paths>
16 |     </logging>
17 |     <transformations>
18 |         <template name="responsive"/>
19 |     </transformations>
20 |     <files>
21 |         <directory>src</directory>
22 |     </files>
23 | </phpdoc>
24 | 


--------------------------------------------------------------------------------
/src/Concurrent/ConcurrentDriver.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Concurrent;
  3 | 
  4 | use Icicle\Concurrent\Exception\TaskException;
  5 | use Icicle\Concurrent\Worker;
  6 | use Icicle\Concurrent\Worker\Pool;
  7 | use Icicle\File\Driver;
  8 | use Icicle\File\Exception\FileException;
  9 | 
 10 | class ConcurrentDriver implements Driver
 11 | {
 12 |     /**
 13 |      * @var \Icicle\Concurrent\Worker\Pool
 14 |      */
 15 |     private $pool;
 16 | 
 17 |     /**
 18 |      * @param \Icicle\Concurrent\Worker\Pool|null $pool
 19 |      */
 20 |     public function __construct(Pool $pool = null)
 21 |     {
 22 |         $this->pool = $pool ?: Worker\pool();
 23 |         if (!$this->pool->isRunning()) {
 24 |             $this->pool->start();
 25 |         }
 26 |     }
 27 | 
 28 |     /**
 29 |      * {@inheritdoc}
 30 |      */
 31 |     public function open(string $path, string $mode): \Generator
 32 |     {
 33 |         $worker = $this->pool->get();
 34 |         
 35 |         $task = new Internal\FileTask('fopen', [$path, $mode]);
 36 | 
 37 |         try {
 38 |             list($id, $size, $append) = yield from $worker->enqueue($task);
 39 |         } catch (TaskException $exception) {
 40 |             throw new FileException('Opening the file failed.', $exception);
 41 |         }
 42 | 
 43 |         return new ConcurrentFile($worker, $id, $path, $size, $append);
 44 |     }
 45 | 
 46 |     /**
 47 |      * {@inheritdoc}
 48 |      */
 49 |     public function unlink(string $path): \Generator
 50 |     {
 51 |         try {
 52 |             return yield from $this->pool->enqueue(new Internal\FileTask('unlink', [$path]));
 53 |         } catch (TaskException $exception) {
 54 |             throw new FileException('Unlinking the file failed.', $exception);
 55 |         }
 56 |     }
 57 | 
 58 |     /**
 59 |      * {@inheritdoc}
 60 |      */
 61 |     public function stat(string $path): \Generator
 62 |     {
 63 |         try {
 64 |             return yield from $this->pool->enqueue(new Internal\FileTask('stat', [$path]));
 65 |         } catch (TaskException $exception) {
 66 |             throw new FileException('Stating the file failed.', $exception);
 67 |         }
 68 |     }
 69 | 
 70 |     /**
 71 |      * {@inheritdoc}
 72 |      */
 73 |     public function rename(string $oldPath, string $newPath): \Generator
 74 |     {
 75 |         try {
 76 |             return yield from $this->pool->enqueue(new Internal\FileTask('rename', [$oldPath, $newPath]));
 77 |         } catch (TaskException $exception) {
 78 |             throw new FileException('Renaming the file failed.', $exception);
 79 |         }
 80 |     }
 81 | 
 82 |     /**
 83 |      * {@inheritdoc}
 84 |      */
 85 |     public function isFile(string $path): \Generator
 86 |     {
 87 |         try {
 88 |             return yield from $this->pool->enqueue(new Internal\FileTask('isfile', [$path]));
 89 |         } catch (TaskException $exception) {
 90 |             throw new FileException('Determining if path is a file failed.', $exception);
 91 |         }
 92 |     }
 93 | 
 94 |     /**
 95 |      * {@inheritdoc}
 96 |      */
 97 |     public function isDir(string $path): \Generator
 98 |     {
 99 |         try {
100 |             return yield from $this->pool->enqueue(new Internal\FileTask('isdir', [$path]));
101 |         } catch (TaskException $exception) {
102 |             throw new FileException('Determine if the path is a directory failed.', $exception);
103 |         }
104 |     }
105 | 
106 |     /**
107 |      * {@inheritdoc}
108 |      */
109 |     public function link(string $source, string $target): \Generator
110 |     {
111 |         try {
112 |             return yield from $this->pool->enqueue(new Internal\FileTask('link', [$source, $target]));
113 |         } catch (TaskException $exception) {
114 |             throw new FileException('Creating the link failed.', $exception);
115 |         }
116 |     }
117 | 
118 |     /**
119 |      * {@inheritdoc}
120 |      */
121 |     public function symlink(string $source, string $target): \Generator
122 |     {
123 |         try {
124 |             return yield from $this->pool->enqueue(new Internal\FileTask('symlink', [$source, $target]));
125 |         } catch (TaskException $exception) {
126 |             throw new FileException('Creating the symlink failed.', $exception);
127 |         }
128 |     }
129 | 
130 |     /**
131 |      * {@inheritdoc}
132 |      */
133 |     public function readlink(string $path): \Generator
134 |     {
135 |         try {
136 |             return yield from $this->pool->enqueue(new Internal\FileTask('readlink', [$path]));
137 |         } catch (TaskException $exception) {
138 |             throw new FileException('Reading the symlink failed.', $exception);
139 |         }
140 |     }
141 | 
142 |     /**
143 |      * {@inheritdoc}
144 |      */
145 |     public function copy(string $source, string $target): \Generator
146 |     {
147 |         try {
148 |             return yield from $this->pool->enqueue(new Internal\FileTask('copy', [$source, $target]));
149 |         } catch (TaskException $exception) {
150 |             throw new FileException('Copying the file failed.', $exception);
151 |         }
152 |     }
153 | 
154 |     /**
155 |      * {@inheritdoc}
156 |      */
157 |     public function mkDir(string $path, int $mode = 0755): \Generator
158 |     {
159 |         try {
160 |             return yield from $this->pool->enqueue(new Internal\FileTask('mkdir', [$path, $mode]));
161 |         } catch (TaskException $exception) {
162 |             throw new FileException('Creating the directory failed.', $exception);
163 |         }
164 |     }
165 | 
166 |     /**
167 |      * {@inheritdoc}
168 |      */
169 |     public function lsDir(string $path): \Generator
170 |     {
171 |         try {
172 |             return yield from $this->pool->enqueue(new Internal\FileTask('lsdir', [$path]));
173 |         } catch (TaskException $exception) {
174 |             throw new FileException('Reading the directory failed.', $exception);
175 |         }
176 |     }
177 | 
178 |     /**
179 |      * {@inheritdoc}
180 |      */
181 |     public function rmDir(string $path): \Generator
182 |     {
183 |         try {
184 |             return yield from $this->pool->enqueue(new Internal\FileTask('rmdir', [$path]));
185 |         } catch (TaskException $exception) {
186 |             throw new FileException('Reading the directory failed.', $exception);
187 |         }
188 |     }
189 | 
190 |     /**
191 |      * {@inheritdoc}
192 |      */
193 |     public function chmod(string $path, int $mode): \Generator
194 |     {
195 |         try {
196 |             return yield from $this->pool->enqueue(new Internal\FileTask('chmod', [$path, $mode]));
197 |         } catch (TaskException $exception) {
198 |             throw new FileException('Creating the directory failed.', $exception);
199 |         }
200 |     }
201 | 
202 |     /**
203 |      * {@inheritdoc}
204 |      */
205 |     public function chown(string $path, int $uid): \Generator
206 |     {
207 |         try {
208 |             return yield from $this->pool->enqueue(new Internal\FileTask('chown', [$path, $uid]));
209 |         } catch (TaskException $exception) {
210 |             throw new FileException('Creating the directory failed.', $exception);
211 |         }
212 |     }
213 | 
214 |     /**
215 |      * {@inheritdoc}
216 |      */
217 |     public function chgrp(string $path, int $gid): \Generator
218 |     {
219 |         try {
220 |             return yield from $this->pool->enqueue(new Internal\FileTask('chgrp', [$path, $gid]));
221 |         } catch (TaskException $exception) {
222 |             throw new FileException('Creating the directory failed.', $exception);
223 |         }
224 |     }
225 | }
226 | 


--------------------------------------------------------------------------------
/src/Concurrent/ConcurrentFile.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Concurrent;
  3 | 
  4 | use Icicle\Concurrent\Exception\TaskException;
  5 | use Icicle\Concurrent\Worker\Worker;
  6 | use Icicle\Coroutine\Coroutine;
  7 | use Icicle\Exception\InvalidArgumentError;
  8 | use Icicle\File\Exception\FileException;
  9 | use Icicle\File\File;
 10 | use Icicle\Stream\Exception\OutOfBoundsException;
 11 | use Icicle\Stream\Exception\UnreadableException;
 12 | use Icicle\Stream\Exception\UnseekableException;
 13 | use Icicle\Stream\Exception\UnwritableException;
 14 | 
 15 | class ConcurrentFile implements File
 16 | {
 17 |     /**
 18 |      * @var \Icicle\Concurrent\Worker\Worker
 19 |      */
 20 |     private $worker;
 21 | 
 22 |     /**
 23 |      * @var int
 24 |      */
 25 |     private $id;
 26 | 
 27 |     /**
 28 |      * @var string
 29 |      */
 30 |     private $path;
 31 | 
 32 |     /**
 33 |      * @var bool
 34 |      */
 35 |     private $open = true;
 36 | 
 37 |     /**
 38 |      * @var int
 39 |      */
 40 |     private $position;
 41 | 
 42 |     /**
 43 |      * @var int
 44 |      */
 45 |     private $size;
 46 | 
 47 |     /**
 48 |      * @var bool
 49 |      */
 50 |     private $append = false;
 51 | 
 52 |     /**
 53 |      * @var bool
 54 |      */
 55 |     private $writable = true;
 56 | 
 57 |     /**
 58 |      * @var \SplQueue
 59 |      */
 60 |     private $queue;
 61 | 
 62 |     /**
 63 |      * @param \Icicle\Concurrent\Worker\Worker $worker
 64 |      * @param int $id
 65 |      * @param string $path
 66 |      * @param int $size
 67 |      * @param bool $append
 68 |      */
 69 |     public function __construct(Worker $worker, int $id, string $path, int $size, bool $append = false)
 70 |     {
 71 |         $this->worker = $worker;
 72 |         $this->id = $id;
 73 |         $this->path = $path;
 74 |         $this->size = $size;
 75 |         $this->append = $append;
 76 |         $this->position = $append ? $size : 0;
 77 | 
 78 |         $this->queue = new \SplQueue();
 79 |     }
 80 | 
 81 |     public function __destruct()
 82 |     {
 83 |         if ($this->isOpen()) {
 84 |             $this->close();
 85 |         }
 86 |     }
 87 | 
 88 |     /**
 89 |      * {@inheritdoc}
 90 |      */
 91 |     public function getPath(): string
 92 |     {
 93 |         return $this->path;
 94 |     }
 95 | 
 96 |     /**
 97 |      * {@inheritdoc}
 98 |      */
 99 |     public function isOpen(): bool
100 |     {
101 |         return $this->open;
102 |     }
103 | 
104 |     /**
105 |      * {@inheritdoc}
106 |      */
107 |     public function close()
108 |     {
109 |         if ($this->open && $this->worker->isRunning()) {
110 |             $coroutine = new Coroutine($this->worker->enqueue(new Internal\FileTask('fclose', [], $this->id)));
111 |             $coroutine->done(null, [$this->worker, 'kill']);
112 |         }
113 | 
114 |         if (!$this->queue->isEmpty()) {
115 |             $exception = new FileException('The file was closed.');
116 |             do {
117 |                 $this->queue->shift()->cancel($exception);
118 |             } while (!$this->queue->isEmpty());
119 |         }
120 | 
121 |         $this->open = false;
122 |         $this->writable = false;
123 |     }
124 | 
125 |     /**
126 |      * {@inheritdoc}
127 |      */
128 |     public function eof(): bool
129 |     {
130 |         return $this->position === $this->size;
131 |     }
132 | 
133 |     /**
134 |      * {@inheritdoc}
135 |      */
136 |     public function read(int $length = 0, string $byte = null, float $timeout = 0): \Generator
137 |     {
138 |         if (!$this->isReadable()) {
139 |             throw new UnreadableException('The file is no longer readable.');
140 |         }
141 | 
142 |         if (0 > $length) {
143 |             throw new InvalidArgumentError('The length must be a non-negative integer.');
144 |         }
145 | 
146 |         if (0 === $length) {
147 |             $length = self::CHUNK_SIZE;
148 |         }
149 | 
150 |         $awaitable = new Coroutine($this->worker->enqueue(new Internal\FileTask('fread', [$length], $this->id)));
151 | 
152 |         if ($timeout) {
153 |             $awaitable = $awaitable->timeout($timeout);
154 |         }
155 | 
156 |         try {
157 |             $data = yield $awaitable;
158 |         } catch (TaskException $exception) {
159 |             $this->close();
160 |             throw new FileException('Reading from the file failed.', $exception);
161 |         }
162 | 
163 |         $byte = strlen($byte) ? $byte[0] : null;
164 | 
165 |         if (null !== $byte && false !== ($position = strpos($data, $byte))) {
166 |             ++$position;
167 |             $data = substr($data, 0, $position);
168 |             yield from $this->seek($this->position + $position);
169 |         } else {
170 |             $this->position += strlen($data);
171 |         }
172 | 
173 |         return $data;
174 |     }
175 | 
176 |     /**
177 |      * {@inheritdoc}
178 |      */
179 |     public function isReadable(): bool
180 |     {
181 |         return $this->isOpen() && !$this->eof();
182 |     }
183 | 
184 |     /**
185 |      * {@inheritdoc}
186 |      */
187 |     public function write(string $data, float $timeout = 0): \Generator
188 |     {
189 |         return $this->send($data, $timeout, false);
190 |     }
191 | 
192 |     /**
193 |      * {@inheritdoc}
194 |      */
195 |     public function end(string $data = '', float $timeout = 0): \Generator
196 |     {
197 |         return $this->send($data, $timeout, true);
198 |     }
199 | 
200 |     /**
201 |      * @coroutine
202 |      *
203 |      * @param string $data
204 |      * @param bool $end
205 |      *
206 |      * @return \Generator
207 |      *
208 |      * @resolve int
209 |      *
210 |      * @throws \Icicle\File\Exception\FileException
211 |      * @throws \Icicle\Stream\Exception\UnwritableException
212 |      */
213 |     protected function send(string $data, float $timeout, bool $end = false): \Generator
214 |     {
215 |         if (!$this->isWritable()) {
216 |             throw new UnwritableException('The file is no longer writable.');
217 |         }
218 | 
219 |         $task = new Internal\FileTask('fwrite', [$data], $this->id);
220 | 
221 |         if ($this->queue->isEmpty()) {
222 |             $awaitable = new Coroutine($this->worker->enqueue($task));
223 |             $this->queue->push($awaitable);
224 |         } else {
225 |             $awaitable = $this->queue->top();
226 |             $awaitable = $awaitable->then(function () use ($task) {
227 |                 return new Coroutine($this->worker->enqueue($task));
228 |             });
229 |         }
230 | 
231 |         if ($end) {
232 |             $this->writable = false;
233 |         }
234 | 
235 |         if ($timeout) {
236 |             $awaitable = $awaitable->timeout($timeout);
237 |         }
238 | 
239 |         try {
240 |             $written = yield $awaitable;
241 | 
242 |             if ($this->append) {
243 |                 $this->size += $written;
244 |             } else {
245 |                 $this->position += $written;
246 |                 if ($this->position > $this->size) {
247 |                     $this->size = $this->position;
248 |                 }
249 |             }
250 |         } catch (TaskException $exception) {
251 |             $this->close();
252 |             throw new FileException('Write to the file failed.', $exception);
253 |         } finally {
254 |             if ($end) {
255 |                 $this->close();
256 |             }
257 |         }
258 | 
259 |         return $written;
260 |     }
261 | 
262 |     /**
263 |      * {@inheritdoc}
264 |      */
265 |     public function isWritable(): bool
266 |     {
267 |         return $this->writable;
268 |     }
269 | 
270 |     /**
271 |      * {@inheritdoc}
272 |      */
273 |     public function seek(int $offset, int $whence = SEEK_SET, float $timeout = 0): \Generator
274 |     {
275 |         if (!$this->isOpen()) {
276 |             throw new UnseekableException('The file is no longer seekable.');
277 |         }
278 | 
279 |         switch ($whence) {
280 |             case \SEEK_SET:
281 |                 break;
282 | 
283 |             case \SEEK_CUR:
284 |                 $offset = $this->position + $offset;
285 |                 break;
286 | 
287 |             case \SEEK_END:
288 |                 $offset = $this->size + $offset;
289 |                 break;
290 | 
291 |             default:
292 |                 throw new InvalidArgumentError('Invalid whence value. Use SEEK_SET, SEEK_CUR, or SEEK_END.');
293 |         }
294 | 
295 |         if (0 > $offset) {
296 |             throw new OutOfBoundsException(sprintf('Invalid offset: %s.', $offset));
297 |         }
298 | 
299 |         $this->position = $offset;
300 | 
301 |         if ($this->position > $this->size) {
302 |             $this->size = $this->position;
303 |         }
304 | 
305 |         $awaitable = new Coroutine(
306 |             $this->worker->enqueue(new Internal\FileTask('fseek', [$offset, \SEEK_SET], $this->id))
307 |         );
308 | 
309 |         if ($timeout) {
310 |             $awaitable = $awaitable->timeout($timeout);
311 |         }
312 | 
313 |         try {
314 |             $this->position = yield $awaitable;
315 |         } catch (TaskException $exception) {
316 |             $this->close();
317 |             throw new FileException('Seeking in the file failed.', $exception);
318 |         }
319 | 
320 |         if ($this->position > $this->size) {
321 |             $this->size = $this->position;
322 |         }
323 | 
324 |         return $this->position;
325 |     }
326 | 
327 |     /**
328 |      * {@inheritdoc}
329 |      */
330 |     public function tell(): int
331 |     {
332 |         return $this->position;
333 |     }
334 | 
335 |     /**
336 |      * {@inheritdoc}
337 |      */
338 |     public function getLength(): int
339 |     {
340 |         return $this->size;
341 |     }
342 | 
343 |     /**
344 |      * {@inheritdoc}
345 |      */
346 |     public function truncate(int $size): \Generator
347 |     {
348 |         if (!$this->isReadable() && !$this->isWritable()) {
349 |             throw new FileException('The file is no longer seekable.');
350 |         }
351 | 
352 |         if (0 > $size) {
353 |             throw new InvalidArgumentError('The size must be a non-negative integer.');
354 |         }
355 | 
356 |         try {
357 |             yield from $this->worker->enqueue(new Internal\FileTask('ftruncate', [$size], $this->id));
358 |         } catch (TaskException $exception) {
359 |             $this->close();
360 |             throw new FileException('Truncating the file failed.', $exception);
361 |         }
362 | 
363 |         $this->size = $size;
364 | 
365 |         if ($this->position > $size) {
366 |             $this->position = $size;
367 |         }
368 | 
369 |         return true;
370 |     }
371 | 
372 |     /**
373 |      * {@inheritdoc}
374 |      */
375 |     public function stat(): \Generator
376 |     {
377 |         if (!$this->isOpen()) {
378 |             throw new FileException('The file has been closed.');
379 |         }
380 | 
381 |         try {
382 |             return yield from $this->worker->enqueue(new Internal\FileTask('fstat', [], $this->id));
383 |         } catch (TaskException $exception) {
384 |             $this->close();
385 |             throw new FileException('Stating file failed.', $exception);
386 |         }
387 |     }
388 | 
389 |     /**
390 |      * {@inheritdoc}
391 |      */
392 |     public function copy(string $path): \Generator
393 |     {
394 |         if (!$this->isOpen()) {
395 |             throw new FileException('The file has been closed.');
396 |         }
397 | 
398 |         try {
399 |             return yield from $this->worker->enqueue(new Internal\FileTask('copy', [$this->path, $path]));
400 |         } catch (TaskException $exception) {
401 |             throw new FileException('Copying the file failed.', $exception);
402 |         }
403 |     }
404 | 
405 |     /**
406 |      * {@inheritdoc}
407 |      */
408 |     public function chown(int $uid): \Generator
409 |     {
410 |         return $this->change('chown', $uid);
411 |     }
412 | 
413 |     /**
414 |      * {@inheritdoc}
415 |      */
416 |     public function chgrp(int $group): \Generator
417 |     {
418 |         return $this->change('chgrp', $group);
419 |     }
420 | 
421 |     /**
422 |      * {@inheritdoc}
423 |      */
424 |     public function chmod(int $mode): \Generator
425 |     {
426 |         return $this->change('chmod', $mode);
427 |     }
428 | 
429 |     /**
430 |      * @param string $operation
431 |      * @param int $value
432 |      *
433 |      * @return \Generator
434 |      *
435 |      * @throws \Icicle\File\Exception\FileException
436 |      */
437 |     private function change(string $operation, int $value): \Generator
438 |     {
439 |         if (!$this->isOpen()) {
440 |             throw new FileException('The file has been closed.');
441 |         }
442 | 
443 |         try {
444 |             return yield from $this->worker->enqueue(new Internal\FileTask($operation, [$this->path, $value]));
445 |         } catch (TaskException $exception) {
446 |             $this->close();
447 |             throw new FileException(sprintf('%s failed.', $operation), $exception);
448 |         }
449 |     }
450 | }
451 | 


--------------------------------------------------------------------------------
/src/Concurrent/Internal/File.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Concurrent\Internal;
  3 | 
  4 | use Icicle\File\Exception\FileException;
  5 | 
  6 | class File
  7 | {
  8 |     /**
  9 |      * @var resource
 10 |      */
 11 |     private $handle;
 12 | 
 13 |     /**
 14 |      * @var string
 15 |      */
 16 |     private $path;
 17 | 
 18 |     /**
 19 |      * @var string
 20 |      */
 21 |     private $mode;
 22 | 
 23 |     /**
 24 |      * @param string $path
 25 |      * @param string $mode
 26 |      *
 27 |      * @throws \Icicle\File\Exception\FileException
 28 |      */
 29 |     public function __construct(string $path, string $mode)
 30 |     {
 31 |         $mode = str_replace(['b', 't'], '', $mode);
 32 | 
 33 |         switch ($mode) {
 34 |             case 'r':
 35 |             case 'r+':
 36 |             case 'w':
 37 |             case 'w+':
 38 |             case 'a':
 39 |             case 'a+':
 40 |             case 'x':
 41 |             case 'x+':
 42 |             case 'c':
 43 |             case 'c+':
 44 |                 break;
 45 | 
 46 |             default:
 47 |                 throw new FileException('Invalid file mode.');
 48 |         }
 49 | 
 50 |         $this->path = $path;
 51 |         $this->mode = $mode;
 52 | 
 53 |         $this->handle = @fopen($this->path, $this->mode . 'b');
 54 | 
 55 |         if (!$this->handle) {
 56 |             $message = 'Could not open the file.';
 57 |             if ($error = error_get_last()) {
 58 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
 59 |             }
 60 |             throw new FileException($message);
 61 |         }
 62 |     }
 63 | 
 64 |     public function __destruct()
 65 |     {
 66 |         if (is_resource($this->handle)) {
 67 |             fclose($this->handle);
 68 |         }
 69 |     }
 70 | 
 71 |     /**
 72 |      * @return int
 73 |      */
 74 |     public function getId(): int
 75 |     {
 76 |         return (int) $this->handle;
 77 |     }
 78 | 
 79 |     /**
 80 |      * @return bool
 81 |      */
 82 |     public function inAppendMode(): bool
 83 |     {
 84 |         return 'a' === $this->mode || 'a+' === $this->mode;
 85 |     }
 86 | 
 87 |     /**
 88 |      * @param int $length
 89 |      *
 90 |      * @return string
 91 |      *
 92 |      * @throws \Icicle\File\Exception\FileException
 93 |      */
 94 |     public function read(int $length): string
 95 |     {
 96 |         $data = @fread($this->handle, $length);
 97 | 
 98 |         if (false === $data || '' === $data) {
 99 |             $message = 'Could not read from the file.';
100 |             if ($error = error_get_last()) {
101 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
102 |             }
103 |             throw new FileException($message);
104 |         }
105 | 
106 |         return $data;
107 |     }
108 | 
109 |     /**
110 |      * @param string $data
111 |      *
112 |      * @return int
113 |      *
114 |      * @throws \Icicle\File\Exception\FileException
115 |      */
116 |     public function write(string $data): int
117 |     {
118 |         $length = strlen($data);
119 | 
120 |         if (0 === $length) {
121 |             return 0;
122 |         }
123 | 
124 |         $written = @fwrite($this->handle, $data, $length);
125 | 
126 |         if (false === $written || $written !== $length) {
127 |             $message = 'Could not write to the file.';
128 |             if ($error = error_get_last()) {
129 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
130 |             }
131 |             throw new FileException($message);
132 |         }
133 | 
134 |         return $written;
135 |     }
136 | 
137 |     /**
138 |      * @param int $offset
139 |      * @param int $whence
140 |      *
141 |      * @return int
142 |      *
143 |      * @throws \Icicle\File\Exception\FileException
144 |      */
145 |     public function seek(int $offset, int $whence = \SEEK_SET): int
146 |     {
147 |         if (-1 === fseek($this->handle, $offset, $whence)) {
148 |             $message = 'Could not move file pointer.';
149 |             if ($error = error_get_last()) {
150 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
151 |             }
152 |             throw new FileException($message);
153 |         }
154 | 
155 |         $position = ftell($this->handle);
156 | 
157 |         if (false === $position) {
158 |             $message = 'Could not get the file pointer position.';
159 |             if ($error = error_get_last()) {
160 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
161 |             }
162 |             throw new FileException($message);
163 |         }
164 | 
165 |         return $position;
166 |     }
167 | 
168 |     /**
169 |      * @return int
170 |      *
171 |      * @throws \Icicle\File\Exception\FileException
172 |      */
173 |     public function tell(): int
174 |     {
175 |         $position = ftell($this->handle);
176 | 
177 |         if (false === $position) {
178 |             $message = 'Could not get file pointer position.';
179 |             if ($error = error_get_last()) {
180 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
181 |             }
182 |             throw new FileException($message);
183 |         }
184 | 
185 |         return $position;
186 |     }
187 | 
188 |     /**
189 |      * @return int
190 |      *
191 |      * @throws \Icicle\File\Exception\FileException
192 |      */
193 |     public function size(): int
194 |     {
195 |         return $this->stat()['size'];
196 |     }
197 | 
198 |     /**
199 |      * @return array
200 |      *
201 |      * @throws \Icicle\File\Exception\FileException
202 |      */
203 |     public function stat(): array
204 |     {
205 |         $result = fstat($this->handle);
206 | 
207 |         if (false === $result) {
208 |             $message = 'Could not stat file.';
209 |             if ($error = error_get_last()) {
210 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
211 |             }
212 |             throw new FileException($message);
213 |         }
214 | 
215 |         return $result;
216 |     }
217 | 
218 |     /**
219 |      * @param int $size
220 |      *
221 |      * @return bool
222 |      *
223 |      * @throws \Icicle\File\Exception\FileException
224 |      */
225 |     public function truncate(int $size): bool
226 |     {
227 |         if (!ftruncate($this->handle, (int) $size)) {
228 |             $message = 'Could not truncate file.';
229 |             if ($error = error_get_last()) {
230 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
231 |             }
232 |             throw new FileException($message);
233 |         }
234 | 
235 |         return true;
236 |     }
237 | }
238 | 


--------------------------------------------------------------------------------
/src/Concurrent/Internal/FileTask.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Concurrent\Internal;
  3 | 
  4 | use Icicle\Concurrent\Worker\{Environment, Task};
  5 | use Icicle\Exception\InvalidArgumentError;
  6 | use Icicle\File\Exception\FileException;
  7 | 
  8 | class FileTask implements Task
  9 | {
 10 |     /**
 11 |      * @var string
 12 |      */
 13 |     private $operation;
 14 | 
 15 |     /**
 16 |      * @var mixed[]
 17 |      */
 18 |     private $args;
 19 | 
 20 |     /**
 21 |      * @var string|null
 22 |      */
 23 |     private $id;
 24 | 
 25 |     /**
 26 |      * @param string $operation
 27 |      * @param array $args
 28 |      * @param int $id File ID.
 29 |      *
 30 |      * @throws \Icicle\Exception\InvalidArgumentError
 31 |      */
 32 |     public function __construct(string $operation, array $args = [], int $id = 0)
 33 |     {
 34 |         if (!strlen($operation)) {
 35 |             throw new InvalidArgumentError('Operation must be a non-empty string.');
 36 |         }
 37 | 
 38 |         $this->operation = $operation;
 39 |         $this->args = $args;
 40 | 
 41 |         if (0 !== $id) {
 42 |             $this->id = $this->makeId($id);
 43 |         }
 44 |     }
 45 | 
 46 |     /**
 47 |      * {@inheritdoc}
 48 |      *
 49 |      * @throws \Icicle\File\Exception\FileException
 50 |      * @throws \Icicle\Exception\InvalidArgumentError
 51 |      */
 52 |     public function run(Environment $environment)
 53 |     {
 54 |         if ('f' === $this->operation[0]) {
 55 |             if ('fopen' === $this->operation) {
 56 |                 $file = new File($this->args[0], $this->args[1]);
 57 |                 $id = $file->getId();
 58 |                 $environment->set($this->makeId($id), $file);
 59 |                 return [$id, $file->stat()['size'], $file->inAppendMode()];
 60 |             }
 61 | 
 62 |             if (null === $this->id) {
 63 |                 throw new FileException('No file ID provided.');
 64 |             }
 65 | 
 66 |             if (!$environment->exists($this->id)) {
 67 |                 throw new FileException('No file handle with the given ID has been opened on the worker.');
 68 |             }
 69 | 
 70 |             if (!($file = $environment->get($this->id)) instanceof File) {
 71 |                 throw new FileException('File storage found in inconsistent state.');
 72 |             }
 73 | 
 74 |             switch ($this->operation) {
 75 |                 case 'fread':
 76 |                 case 'fwrite':
 77 |                 case 'fseek':
 78 |                 case 'fstat':
 79 |                 case 'ftruncate':
 80 |                     return [$file, substr($this->operation, 1)](...$this->args);
 81 | 
 82 |                 case 'fclose':
 83 |                     $environment->delete($this->id);
 84 |                     return true;
 85 | 
 86 |                 default:
 87 |                     throw new InvalidArgumentError('Invalid operation.');
 88 |             }
 89 |         }
 90 | 
 91 |         switch ($this->operation) {
 92 |             case 'stat':
 93 |             case 'unlink':
 94 |             case 'rename':
 95 |             case 'copy':
 96 |             case 'link':
 97 |             case 'symlink':
 98 |             case 'readlink':
 99 |             case 'isfile':
100 |             case 'isdir':
101 |             case 'mkdir':
102 |             case 'lsdir':
103 |             case 'rmdir':
104 |             case 'chmod':
105 |             case 'chown':
106 |             case 'chgrp':
107 |                 return [$this, $this->operation](...$this->args);
108 | 
109 |             default:
110 |                 throw new InvalidArgumentError('Invalid operation.');
111 |         }
112 |     }
113 | 
114 |     /**
115 |      * @param int $id
116 |      *
117 |      * @return string
118 |      */
119 |     private function makeId(int $id): string
120 |     {
121 |         return '__file_' . $id;
122 |     }
123 | 
124 |     /**
125 |      * @param string $path
126 |      *
127 |      * @return bool
128 |      *
129 |      * @throws \Icicle\File\Exception\FileException
130 |      */
131 |     private function unlink(string $path): bool
132 |     {
133 |         if (!@unlink($path)) {
134 |             $message = 'Could not unlink file.';
135 |             if ($error = error_get_last()) {
136 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
137 |             }
138 |             throw new FileException($message);
139 |         }
140 | 
141 |         return true;
142 |     }
143 | 
144 |     /**
145 |      * @param string $oldPath
146 |      * @param string $newPath
147 |      *
148 |      * @return bool
149 |      *
150 |      * @throws \Icicle\File\Exception\FileException
151 |      */
152 |     private function rename(string $oldPath, string $newPath): bool
153 |     {
154 |         if (!@rename($oldPath, $newPath)) {
155 |             $message = 'Could not rename file.';
156 |             if ($error = error_get_last()) {
157 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
158 |             }
159 |             throw new FileException($message);
160 |         }
161 | 
162 |         return true;
163 |     }
164 | 
165 |     /**
166 |      * @param string $path
167 |      *
168 |      * @return array
169 |      *
170 |      * @throws \Icicle\File\Exception\FileException
171 |      */
172 |     private function stat(string $path): array
173 |     {
174 |         $result = @stat($path);
175 | 
176 |         if (false === $result) {
177 |             $message = 'Could not stat file.';
178 |             if ($error = error_get_last()) {
179 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
180 |             }
181 |             throw new FileException($message);
182 |         }
183 | 
184 |         return $result;
185 |     }
186 | 
187 |     /**
188 |      * @param string $path
189 |      *
190 |      * @return bool
191 |      */
192 |     private function isfile(string $path): bool
193 |     {
194 |         return is_file($path);
195 |     }
196 | 
197 |     /**
198 |      * @param string $path
199 |      *
200 |      * @return bool
201 |      */
202 |     private function isdir(string $path): bool
203 |     {
204 |         return is_dir($path);
205 |     }
206 | 
207 |     /**
208 |      * @param string $source
209 |      * @param string $target
210 |      *
211 |      * @return int
212 |      *
213 |      * @throws \Icicle\File\Exception\FileException
214 |      */
215 |     private function copy(string $source, string $target): int
216 |     {
217 |         if (!@copy($source, $target)) {
218 |             $message = 'Could not copy file.';
219 |             if ($error = error_get_last()) {
220 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
221 |             }
222 |             throw new FileException($message);
223 |         }
224 | 
225 |         return $this->stat($target)['size'];
226 |     }
227 | 
228 |     /**
229 |      * @param string $source
230 |      * @param string $target
231 |      *
232 |      * @return bool
233 |      *
234 |      * @throws \Icicle\File\Exception\FileException
235 |      */
236 |     private function link(string $source, string $target): bool
237 |     {
238 |         if (!@link($source, $target)) {
239 |             $message = 'Could not create link.';
240 |             if ($error = error_get_last()) {
241 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
242 |             }
243 |             throw new FileException($message);
244 |         }
245 | 
246 |         return true;
247 |     }
248 | 
249 |     /**
250 |      * @param string $source
251 |      * @param string $target
252 |      *
253 |      * @return bool
254 |      *
255 |      * @throws \Icicle\File\Exception\FileException
256 |      */
257 |     private function symlink(string $source, string $target): bool
258 |     {
259 |         if (!@symlink($source, $target)) {
260 |             $message = 'Could not create symlink.';
261 |             if ($error = error_get_last()) {
262 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
263 |             }
264 |             throw new FileException($message);
265 |         }
266 | 
267 |         return true;
268 |     }
269 | 
270 |     /**
271 |      * @param string $path
272 |      *
273 |      * @return string
274 |      *
275 |      * @throws \Icicle\File\Exception\FileException
276 |      */
277 |     private function readlink(string $path): string
278 |     {
279 |         $result = @readlink($path);
280 | 
281 |         if (false === $result) {
282 |             $message = 'Could not read symlink.';
283 |             if ($error = error_get_last()) {
284 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
285 |             }
286 |             throw new FileException($message);
287 |         }
288 | 
289 |         return $result;
290 |     }
291 | 
292 |     /**
293 |      * @param string $path
294 |      * @param int $mode
295 |      *
296 |      * @return bool
297 |      *
298 |      * @throws \Icicle\File\Exception\FileException
299 |      */
300 |     private function mkdir(string $path, int $mode = 0755): bool
301 |     {
302 |         if (!@mkdir($path, $mode)) {
303 |             $message = 'Could not create directory.';
304 |             if ($error = error_get_last()) {
305 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
306 |             }
307 |             throw new FileException($message);
308 |         }
309 | 
310 |         return true;
311 |     }
312 | 
313 |     /**
314 |      * @param string $path
315 |      *
316 |      * @return array
317 |      *
318 |      * @throws \Icicle\File\Exception\FileException
319 |      */
320 |     private function lsdir(string $path): array
321 |     {
322 |         $result = @scandir($path);
323 | 
324 |         if (false === $result) {
325 |             $message = 'Could not read directory.';
326 |             if ($error = error_get_last()) {
327 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
328 |             }
329 |             throw new FileException($message);
330 |         }
331 | 
332 |         return array_values(array_diff($result, ['.', '..']));
333 |     }
334 | 
335 |     /**
336 |      * @param string $path
337 |      *
338 |      * @return bool
339 |      *
340 |      * @throws \Icicle\File\Exception\FileException
341 |      */
342 |     private function rmdir(string $path): bool
343 |     {
344 |         if (!@rmdir($path)) {
345 |             $message = 'Could not remove directory.';
346 |             if ($error = error_get_last()) {
347 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
348 |             }
349 |             throw new FileException($message);
350 |         }
351 | 
352 |         return true;
353 |     }
354 | 
355 |     /**
356 |      * @param string $path
357 |      * @param int $owner
358 |      *
359 |      * @return bool
360 |      *
361 |      * @throws \Icicle\File\Exception\FileException
362 |      */
363 |     private function chown(string $path, int $owner): bool
364 |     {
365 |         if (!@chown($path, $owner)) {
366 |             $message = 'Could not change file owner.';
367 |             if ($error = error_get_last()) {
368 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
369 |             }
370 |             throw new FileException($message);
371 |         }
372 | 
373 |         return true;
374 |     }
375 | 
376 |     /**
377 |      * @param string $path
378 |      * @param int $group
379 |      *
380 |      * @return bool
381 |      *
382 |      * @throws \Icicle\File\Exception\FileException
383 |      */
384 |     private function chgrp(string $path, int $group): bool
385 |     {
386 |         if (!@chgrp($path, $group)) {
387 |             $message = 'Could not change file group.';
388 |             if ($error = error_get_last()) {
389 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
390 |             }
391 |             throw new FileException($message);
392 |         }
393 | 
394 |         return true;
395 |     }
396 | 
397 |     /**
398 |      * @param string $path
399 |      * @param int $mode
400 |      *
401 |      * @return bool
402 |      *
403 |      * @throws \Icicle\File\Exception\FileException
404 |      */
405 |     private function chmod(string $path, int $mode): bool
406 |     {
407 |         if (!@chmod($path, $mode)) {
408 |             $message = 'Could not change file mode.';
409 |             if ($error = error_get_last()) {
410 |                 $message .= sprintf(' Errno: %d; %s', $error['type'], $error['message']);
411 |             }
412 |             throw new FileException($message);
413 |         }
414 | 
415 |         return true;
416 |     }
417 | }
418 | 


--------------------------------------------------------------------------------
/src/Driver.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File;
  3 | 
  4 | interface Driver
  5 | {
  6 |     /**
  7 |      * Opens the file at the file path using the given mode. Modes are identical to those of fopen().
  8 |      *
  9 |      * @coroutine
 10 |      *
 11 |      * @param string $path
 12 |      * @param string $mode
 13 |      *
 14 |      * @return \Generator
 15 |      *
 16 |      * @resolve \Icicle\File\FileInterface
 17 |      *
 18 |      * @throws \Icicle\File\Exception\FileException If the file is not found or cannot be opened.
 19 |      */
 20 |     public function open(string $path, string $mode): \Generator;
 21 | 
 22 |     /**
 23 |      * @coroutine
 24 |      *
 25 |      * @param string $path
 26 |      *
 27 |      * @return \Generator
 28 |      *
 29 |      * @resolve bool
 30 |      *
 31 |      * @throws \Icicle\File\Exception\FileException If unlinking fails.
 32 |      */
 33 |     public function unlink(string $path): \Generator;
 34 | 
 35 |     /**
 36 |      * @coroutine
 37 |      *
 38 |      * @param string $path
 39 |      *
 40 |      * @return \Generator
 41 |      *
 42 |      * @resolve array
 43 |      *
 44 |      * @throws \Icicle\File\Exception\FileException If getting the file stats fails.
 45 |      */
 46 |     public function stat(string $path): \Generator;
 47 | 
 48 |     /**
 49 |      * @coroutine
 50 |      *
 51 |      * @param string $source
 52 |      * @param string $target
 53 |      *
 54 |      * @return \Generator
 55 |      *
 56 |      * @resolve bool
 57 |      *
 58 |      * @throws \Icicle\File\Exception\FileException If creatingn the hard link fails.
 59 |      */
 60 |     public function link(string $source, string $target): \Generator;
 61 | 
 62 |     /**
 63 |      * @coroutine
 64 |      *
 65 |      * @param string $source
 66 |      * @param string $target
 67 |      *
 68 |      * @return \Generator
 69 |      *
 70 |      * @resolve bool
 71 |      *
 72 |      * @throws \Icicle\File\Exception\FileException If creating the symlink fails.
 73 |      */
 74 |     public function symlink(string $source, string $target): \Generator;
 75 | 
 76 |     /**
 77 |      * @coroutine
 78 |      *
 79 |      * @param string $path
 80 |      *
 81 |      * @return \Generator
 82 |      *
 83 |      * @resolve bool
 84 |      *
 85 |      * @throws \Icicle\File\Exception\FileException If reading the symlink fails.
 86 |      */
 87 |     public function readlink(string $path): \Generator;
 88 | 
 89 |     /**
 90 |      * @coroutine
 91 |      *
 92 |      * @param string $oldPath
 93 |      * @param string $newPath
 94 |      *
 95 |      * @return \Generator
 96 |      *
 97 |      * @resolve bool
 98 |      */
 99 |     public function rename(string $oldPath, string $newPath): \Generator;
100 | 
101 |     /**
102 |      * @coroutine
103 |      *
104 |      * @param string $source
105 |      * @param string $target
106 |      *
107 |      * @return \Generator
108 |      *
109 |      * @resolve int Size of the copied file.
110 |      *
111 |      * @throws \Icicle\File\Exception\FileException If unlinking fails.
112 |      */
113 |     public function copy(string $source, string $target): \Generator;
114 | 
115 |     /**
116 |      * @coroutine
117 |      *
118 |      * @param string $path
119 |      * @param int $mode
120 |      *
121 |      * @return \Generator
122 |      *
123 |      * @resolve bool
124 |      */
125 |     public function mkDir(string $path, int $mode = 0755): \Generator;
126 | 
127 |     /**
128 |      * @coroutine
129 |      *
130 |      * @param $path
131 |      *
132 |      * @return \Generator
133 |      *
134 |      * @resolve string[]
135 |      */
136 |     public function lsDir(string $path): \Generator;
137 | 
138 |     /**
139 |      * @coroutine
140 |      *
141 |      * @param $path
142 |      *
143 |      * @return \Generator
144 |      *
145 |      * @resolve bool
146 |      */
147 |     public function rmDir(string $path): \Generator;
148 | 
149 |     /**
150 |      * @coroutine
151 |      *
152 |      * @param string $path
153 |      *
154 |      * @return \Generator
155 |      *
156 |      * @resolve bool
157 |      */
158 |     public function isFile(string $path): \Generator;
159 | 
160 |     /**
161 |      * @coroutine
162 |      *
163 |      * @param string $path
164 |      *
165 |      * @return \Generator
166 |      *
167 |      * @resolve bool
168 |      */
169 |     public function isDir(string $path): \Generator;
170 | 
171 |     /**
172 |      * @coroutine
173 |      *
174 |      * @param string $path
175 |      * @param int $uid
176 |      *
177 |      * @return \Generator
178 |      *
179 |      * @resolve bool
180 |      */
181 |     public function chown(string $path, int $uid): \Generator;
182 | 
183 |     /**
184 |      * @coroutine
185 |      *
186 |      * @param string $path
187 |      * @param int $gid
188 |      *
189 |      * @return \Generator
190 |      *
191 |      * @resolve bool
192 |      */
193 |     public function chgrp(string $path, int $gid): \Generator;
194 | 
195 |     /**
196 |      * @coroutine
197 |      *
198 |      * @param string $path
199 |      * @param int $mode
200 |      *
201 |      * @return \Generator
202 |      *
203 |      * @resolve bool
204 |      */
205 |     public function chmod(string $path, int $mode): \Generator;
206 | }
207 | 


--------------------------------------------------------------------------------
/src/Eio/EioDriver.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Eio;
  3 | 
  4 | use Icicle\Awaitable\Delayed;
  5 | use Icicle\File\{Driver, Exception\FileException};
  6 | use Icicle\Loop;
  7 | 
  8 | class EioDriver implements Driver
  9 | {
 10 |     /**
 11 |      * @var string[]
 12 |      */
 13 |     private static $statKeys = [
 14 |         0  => 'dev',
 15 |         1  => 'ino',
 16 |         2  => 'mode',
 17 |         3  => 'nlink',
 18 |         4  => 'uid',
 19 |         5  => 'gid',
 20 |         6  => 'rdev',
 21 |         7  => 'size',
 22 |         8  => 'atime',
 23 |         9  => 'mtime',
 24 |         10 => 'ctime',
 25 |         11 => 'blksize',
 26 |         12 => 'blocks',
 27 |     ];
 28 | 
 29 |     /**
 30 |      * @var \Icicle\File\Eio\Internal\EioPoll
 31 |      */
 32 |     private $poll;
 33 | 
 34 |     /**
 35 |      * @return bool
 36 |      */
 37 |     public static function enabled(): bool
 38 |     {
 39 |         return \extension_loaded('eio');
 40 |     }
 41 | 
 42 |     public function __construct()
 43 |     {
 44 |         // @codeCoverageIgnoreStart
 45 |         if (!self::enabled()) {
 46 |             throw new FileException('Requires the eio extension.');
 47 |         } // @codeCoverageIgnoreEnd
 48 | 
 49 |         $this->poll = new Internal\EioPoll();
 50 |     }
 51 | 
 52 |     /**
 53 |      * @param string $mode
 54 |      *
 55 |      * @return int
 56 |      *
 57 |      * @throws \Icicle\File\Exception\FileException
 58 |      */
 59 |     private function makeFlags(string $mode): int
 60 |     {
 61 |         return \EIO_O_NONBLOCK | \EIO_O_FSYNC | $this->parseMode($mode);
 62 |     }
 63 | 
 64 |     /**
 65 |      * @param string $mode
 66 |      *
 67 |      * @return int
 68 |      *
 69 |      * @throws \Icicle\File\Exception\FileException
 70 |      */
 71 |     private function parseMode(string $mode): int
 72 |     {
 73 |         $mode = str_replace(['b', 't'], '', $mode);
 74 | 
 75 |         switch ($mode) {
 76 |             case 'r':  return \EIO_O_RDONLY;
 77 |             case 'r+': return \EIO_O_RDWR;
 78 |             case 'w':  return \EIO_O_WRONLY | \EIO_O_TRUNC | \EIO_O_CREAT;
 79 |             case 'w+': return \EIO_O_RDWR | \EIO_O_TRUNC | \EIO_O_CREAT;
 80 |             case 'a':  return \EIO_O_WRONLY | \EIO_O_APPEND | \EIO_O_CREAT;
 81 |             case 'a+': return \EIO_O_RDWR | \EIO_O_APPEND | \EIO_O_CREAT;
 82 |             case 'x':  return \EIO_O_WRONLY | \EIO_O_CREAT | \EIO_O_EXCL;
 83 |             case 'x+': return \EIO_O_RDWR | \EIO_O_CREAT | \EIO_O_EXCL;
 84 |             case 'c':  return \EIO_O_WRONLY | \EIO_O_CREAT;
 85 |             case 'c+': return \EIO_O_RDWR | \EIO_O_CREAT;
 86 | 
 87 |             default:
 88 |                 throw new FileException('Invalid file mode.');
 89 |         }
 90 |     }
 91 | 
 92 |     /**
 93 |      * {@inheritdoc}
 94 |      */
 95 |     public function open(string $path, string $mode): \Generator
 96 |     {
 97 |         $flags = $this->makeFlags($mode);
 98 |         $chmod = ($flags & \EIO_O_CREAT) ? 0644 : 0;
 99 | 
100 |         $delayed = new Delayed();
101 |         \eio_open($path, $flags, $chmod, null, function (Delayed $delayed, $handle, $req) {
102 |             if (-1 === $handle) {
103 |                 $delayed->reject(new FileException(
104 |                     sprintf('Opening the file failed: %s.', \eio_get_last_error($req))
105 |                 ));
106 |             } else {
107 |                 $delayed->resolve($handle);
108 |             }
109 |         }, $delayed);
110 | 
111 |         $this->poll->listen();
112 | 
113 |         try {
114 |             $handle = yield $delayed;
115 |         } finally {
116 |             $this->poll->done();
117 |         }
118 | 
119 |         if ($flags & \EIO_O_TRUNC) { // File truncated.
120 |             $size = 0;
121 |         } else {
122 |             $delayed = new Delayed();
123 |             \eio_fstat($handle, null, function (Delayed $delayed, $result, $req) {
124 |                 if (-1 === $result) {
125 |                     $delayed->reject(new FileException(
126 |                         sprintf('Finding file size failed: %s.', \eio_get_last_error($req))
127 |                     ));
128 |                 } else {
129 |                     $delayed->resolve($result['size']);
130 |                 }
131 |             }, $delayed);
132 | 
133 |             $this->poll->listen();
134 | 
135 |             try {
136 |                 $size = yield $delayed;
137 |             } finally {
138 |                 $this->poll->done();
139 |             }
140 |         }
141 | 
142 |         return new EioFile($this->poll, $handle, $path, $size, (bool) ($flags & \EIO_O_APPEND));
143 |     }
144 | 
145 |     /**
146 |      * {@inheritdoc}
147 |      */
148 |     public function unlink(string $path): \Generator
149 |     {
150 |         if (!(yield from $this->isFile($path))) { // Ensure file exists before attempting to unlink.
151 |             throw new FileException('File does not exist or is a directory.');
152 |         }
153 | 
154 |         $delayed = new Delayed();
155 |         \eio_unlink($path, null, function (Delayed $delayed, $result, $req) {
156 |             if (-1 === $result) {
157 |                 $delayed->reject(new FileException(
158 |                     sprintf('Unlinking the file failed: %s.', \eio_get_last_error($req))
159 |                 ));
160 |             } else {
161 |                 $delayed->resolve(true);
162 |             }
163 |         }, $delayed);
164 | 
165 |         $this->poll->listen();
166 | 
167 |         try {
168 |             $result = yield $delayed;
169 |         } finally {
170 |             $this->poll->done();
171 |         }
172 | 
173 |         return $result;
174 |     }
175 | 
176 |     /**
177 |      * {@inheritdoc}
178 |      */
179 |     public function rename(string $oldPath, string $newPath): \Generator
180 |     {
181 |         $delayed = new Delayed();
182 |         \eio_rename($oldPath, $newPath, null, function (Delayed $delayed, $result, $req) {
183 |             if (-1 === $result) {
184 |                 $delayed->reject(new FileException(
185 |                     sprintf('Renaming the file failed: %s.', \eio_get_last_error($req))
186 |                 ));
187 |             } else {
188 |                 $delayed->resolve(true);
189 |             }
190 |         }, $delayed);
191 | 
192 |         $this->poll->listen();
193 | 
194 |         try {
195 |             $result = yield $delayed;
196 |         } finally {
197 |             $this->poll->done();
198 |         }
199 | 
200 |         return $result;
201 |     }
202 | 
203 |     /**
204 |      * {@inheritdoc}
205 |      */
206 |     public function stat(string $path): \Generator
207 |     {
208 |         $delayed = new Delayed();
209 |         \eio_stat($path, null, function (Delayed $delayed, $result, $req) {
210 |             if (-1 === $result) {
211 |                 $delayed->reject(new FileException(
212 |                     sprintf('Could not stat file: %s.', \eio_get_last_error($req))
213 |                 ));
214 |             } else {
215 |                 $delayed->resolve($result);
216 |             }
217 |         }, $delayed);
218 | 
219 |         $this->poll->listen();
220 | 
221 |         try {
222 |             $stat = yield $delayed;
223 |         } finally {
224 |             $this->poll->done();
225 |         }
226 | 
227 |         $numeric = [];
228 |         foreach (self::getStatKeys() as $key => $name) {
229 |             $numeric[$key] = $stat[$name];
230 |         }
231 | 
232 |         return array_merge($numeric, $stat);
233 |     }
234 | 
235 |     /**
236 |      * {@inheritdoc}
237 |      */
238 |     public function isFile(string $path): \Generator
239 |     {
240 |         try {
241 |             $result = yield from $this->stat($path);
242 |             return (bool) ($result['mode'] & \EIO_S_IFREG);
243 |         } catch (FileException $exception) {
244 |             return false;
245 |         }
246 |     }
247 | 
248 |     /**
249 |      * {@inheritdoc}
250 |      */
251 |     public function isDir(string $path): \Generator
252 |     {
253 |         try {
254 |             $result = yield from $this->stat($path);
255 |             return !($result['mode'] & \EIO_S_IFREG);
256 |         } catch (FileException $exception) {
257 |             return false;
258 |         }
259 |     }
260 | 
261 |     /**
262 |      * {@inheritdoc}
263 |      */
264 |     public function link(string $source, string $target): \Generator
265 |     {
266 |         return $this->doLink($source, $target, true);
267 |     }
268 | 
269 |     /**
270 |      * {@inheritdoc}
271 |      */
272 |     public function symlink(string $source, string $target): \Generator
273 |     {
274 |         return $this->doLink($source, $target, false);
275 |     }
276 | 
277 |     /**
278 |      * {@inheritdoc}
279 |      */
280 |     private function doLink(string $source, string $target, bool $hard): \Generator
281 |     {
282 |         $callback = function (Delayed $delayed, $result, $req) {
283 |             if (-1 === $result) {
284 |                 $delayed->reject(new FileException(
285 |                     sprintf('Could not create link: %s.', \eio_get_last_error($req))
286 |                 ));
287 |             } else {
288 |                 $delayed->resolve(true);
289 |             }
290 |         };
291 | 
292 |         $delayed = new Delayed();
293 | 
294 |         if ($hard) {
295 |             \eio_link($source, $target, null, $callback, $delayed);
296 |         } else {
297 |             \eio_symlink($source, $target, null, $callback, $delayed);
298 |         }
299 | 
300 |         $this->poll->listen();
301 | 
302 |         try {
303 |             $result = yield $delayed;
304 |         } finally {
305 |             $this->poll->done();
306 |         }
307 | 
308 |         return $result;
309 |     }
310 | 
311 |     /**
312 |      * {@inheritdoc}
313 |      */
314 |     public function readlink(string $path): \Generator
315 |     {
316 |         $delayed = new Delayed();
317 |         \eio_readlink($path, null, function (Delayed $delayed, $result, $req) {
318 |             if (-1 === $result) {
319 |                 $delayed->reject(new FileException(
320 |                     sprintf('Could not read symlink: %s.', \eio_get_last_error($req))
321 |                 ));
322 |             } else {
323 |                 $delayed->resolve($result);
324 |             }
325 |         }, $delayed);
326 | 
327 |         $this->poll->listen();
328 | 
329 |         try {
330 |             $result = yield $delayed;
331 |         } finally {
332 |             $this->poll->done();
333 |         }
334 | 
335 |         return $result;
336 |     }
337 | 
338 |     /**
339 |      * {@inheritdoc}
340 |      */
341 |     public function copy(string $source, string $target): \Generator
342 |     {
343 |         /** @var \Icicle\File\Eio\EioFile $file */
344 |         $file = yield from $this->open($source, 'r');
345 |         $written = yield from $file->copy($target);
346 |         $file->close();
347 |         return $written;
348 |     }
349 | 
350 |     /**
351 |      * {@inheritdoc}
352 |      */
353 |     public function mkDir(string $path, int $mode = 0755): \Generator
354 |     {
355 |         $delayed = new Delayed();
356 |         \eio_mkdir($path, $mode, null, function (Delayed $delayed, $result, $req) {
357 |             if (-1 === $result) {
358 |                 $delayed->reject(new FileException(
359 |                     sprintf('Could not create directory: %s.', \eio_get_last_error($req))
360 |                 ));
361 |             } else {
362 |                 $delayed->resolve(true);
363 |             }
364 |         }, $delayed);
365 | 
366 |         $this->poll->listen();
367 | 
368 |         try {
369 |             $result = yield $delayed;
370 |         } finally {
371 |             $this->poll->done();
372 |         }
373 | 
374 |         return $result;
375 |     }
376 | 
377 |     /**
378 |      * {@inheritdoc}
379 |      */
380 |     public function lsDir(string $path): \Generator
381 |     {
382 |         $delayed = new Delayed();
383 |         \eio_readdir($path, 0, null, function (Delayed $delayed, $result, $req) {
384 |             if (-1 === $result) {
385 |                 $delayed->reject(new FileException(
386 |                     sprintf('Could not read directory: %s.', \eio_get_last_error($req))
387 |                 ));
388 |             } else {
389 |                 $result = $result['names'];
390 |                 sort($result, \SORT_STRING | \SORT_NATURAL | \SORT_FLAG_CASE);
391 |                 $delayed->resolve($result);
392 |             }
393 |         }, $delayed);
394 | 
395 |         $this->poll->listen();
396 | 
397 |         try {
398 |             $result = yield $delayed;
399 |         } finally {
400 |             $this->poll->done();
401 |         }
402 | 
403 |         return $result;
404 |     }
405 | 
406 |     /**
407 |      * {@inheritdoc}
408 |      */
409 |     public function rmDir(string $path): \Generator
410 |     {
411 |         $delayed = new Delayed();
412 |         \eio_rmdir($path, null, function (Delayed $delayed, $result, $req) {
413 |             if (-1 === $result) {
414 |                 $delayed->reject(new FileException(
415 |                     sprintf('Could not remove directory: %s.', \eio_get_last_error($req))
416 |                 ));
417 |             } else {
418 |                 $delayed->resolve(true);
419 |             }
420 |         }, $delayed);
421 | 
422 |         $this->poll->listen();
423 | 
424 |         try {
425 |             $result = yield $delayed;
426 |         } finally {
427 |             $this->poll->done();
428 |         }
429 | 
430 |         return $result;
431 |     }
432 | 
433 |     /**
434 |      * {@inheritdoc}
435 |      */
436 |     public function chown(string $path, int $uid): \Generator
437 |     {
438 |         return $this->chowngrp($path, $uid, -1);
439 |     }
440 | 
441 |     /**
442 |      * {@inheritdoc}
443 |      */
444 |     public function chgrp(string $path, int $gid): \Generator
445 |     {
446 |         return $this->chowngrp($path, -1, $gid);
447 |     }
448 | 
449 |     /**
450 |      * @coroutine
451 |      *
452 |      * @param int $uid
453 |      * @param int $gid
454 |      *
455 |      * @return \Generator
456 |      *
457 |      * @resolve bool
458 |      */
459 |     private function chowngrp(string $path, int $uid, int $gid): \Generator
460 |     {
461 |         $delayed = new Delayed();
462 |         \eio_chown($path, $uid, $gid, null, function (Delayed $delayed, $result, $req) {
463 |             if (-1 === $result) {
464 |                 $delayed->reject(new FileException(
465 |                     sprintf('Changing the owner or group failed: %s.', \eio_get_last_error($req))
466 |                 ));
467 |             } else {
468 |                 $delayed->resolve(true);
469 |             }
470 |         }, $delayed);
471 | 
472 |         $this->poll->listen();
473 | 
474 |         try {
475 |             $result = yield $delayed;
476 |         } finally {
477 |             $this->poll->done();
478 |         }
479 | 
480 |         return $result;
481 |     }
482 | 
483 |     /**
484 |      * {@inheritdoc}
485 |      */
486 |     public function chmod(string $path, int $mode): \Generator
487 |     {
488 |         $delayed = new Delayed();
489 |         \eio_chmod($path, $mode, null, function (Delayed $delayed, $result, $req) {
490 |             if (-1 === $result) {
491 |                 $delayed->reject(new FileException(
492 |                     sprintf('Changing the owner failed: %s.', \eio_get_last_error($req))
493 |                 ));
494 |             } else {
495 |                 $delayed->resolve(true);
496 |             }
497 |         }, $delayed);
498 | 
499 |         $this->poll->listen();
500 | 
501 |         try {
502 |             $result = yield $delayed;
503 |         } finally {
504 |             $this->poll->done();
505 |         }
506 | 
507 |         return $result;
508 |     }
509 | 
510 |     /**
511 |      * @return string[]
512 |      */
513 |     public static function getStatKeys(): array
514 |     {
515 |         return self::$statKeys;
516 |     }
517 | }
518 | 


--------------------------------------------------------------------------------
/src/Eio/EioFile.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File\Eio;
  3 | 
  4 | use Icicle\Awaitable\Awaitable;
  5 | use Icicle\Awaitable\Delayed;
  6 | use Icicle\Exception\InvalidArgumentError;
  7 | use Icicle\File\{Exception\FileException, File};
  8 | use Icicle\Stream\Exception\{OutOfBoundsException, UnreadableException, UnseekableException, UnwritableException};
  9 | 
 10 | class EioFile implements File
 11 | {
 12 |     /**
 13 |      * @var \Icicle\File\Eio\Internal\EioPoll
 14 |      */
 15 |     private $poll;
 16 | 
 17 |     /**
 18 |      * @var int
 19 |      */
 20 |     private $handle;
 21 | 
 22 |     /**
 23 |      * @var string
 24 |      */
 25 |     private $path;
 26 | 
 27 |     /**
 28 |      * @var int
 29 |      */
 30 |     private $size = 0;
 31 | 
 32 |     /**
 33 |      * @var int
 34 |      */
 35 |     private $position = 0;
 36 | 
 37 |     /**
 38 |      * @var bool
 39 |      */
 40 |     private $append = false;
 41 | 
 42 |     /**
 43 |      * @var \SplQueue
 44 |      */
 45 |     private $queue;
 46 | 
 47 |     /**
 48 |      * @var bool
 49 |      */
 50 |     private $writable = true;
 51 | 
 52 |     /**
 53 |      * @param \Icicle\File\Eio\Internal\EioPoll $poll
 54 |      * @param int $handle
 55 |      * @param string $path
 56 |      * @param int $size
 57 |      * @param bool $append
 58 |      */
 59 |     public function __construct(Internal\EioPoll $poll, int $handle, string $path, int $size, bool $append = false)
 60 |     {
 61 |         $this->poll = $poll;
 62 |         $this->handle = $handle;
 63 |         $this->path = $path;
 64 |         $this->size = $size;
 65 |         $this->append = $append;
 66 |         $this->position = $append ? $size : 0;
 67 | 
 68 |         $this->queue = new \SplQueue();
 69 |     }
 70 | 
 71 |     public function __destruct()
 72 |     {
 73 |         $this->close();
 74 |     }
 75 | 
 76 |     /**
 77 |      * {@inheritdoc}
 78 |      */
 79 |     public function getPath(): string
 80 |     {
 81 |         return $this->path;
 82 |     }
 83 | 
 84 |     /**
 85 |      * {@inheritdoc}
 86 |      */
 87 |     public function isOpen(): bool
 88 |     {
 89 |         return 0 !== $this->handle;
 90 |     }
 91 | 
 92 |     /**
 93 |      * {@inheritdoc}
 94 |      */
 95 |     public function close()
 96 |     {
 97 |         if (0 !== $this->handle) {
 98 |             \eio_close($this->handle);
 99 |             $this->handle = 0;
100 |         }
101 | 
102 |         $this->writable = false;
103 | 
104 |         if (!$this->queue->isEmpty()) {
105 |             $exception = new FileException('The file was closed.');
106 |             do {
107 |                 $this->queue->shift()->cancel($exception);
108 |             } while (!$this->queue->isEmpty());
109 |         }
110 |     }
111 | 
112 |     /**
113 |      * {@inheritdoc}
114 |      */
115 |     public function eof(): bool
116 |     {
117 |         return $this->position === $this->size;
118 |     }
119 | 
120 |     /**
121 |      * {@inheritdoc}
122 |      */
123 |     public function read(int $length = 0, string $byte = null, float $timeout = 0): \Generator
124 |     {
125 |         if (!$this->isReadable()) {
126 |             throw new UnreadableException('The file is no longer readable.');
127 |         }
128 | 
129 |         if (0 > $length) {
130 |             throw new InvalidArgumentError('The length must be a non-negative integer.');
131 |         }
132 | 
133 |         if (0 === $length) {
134 |             $length = self::CHUNK_SIZE;
135 |         }
136 | 
137 |         $remaining = $this->size - $this->position;
138 |         $length = $length > $remaining ? $remaining : $length;
139 | 
140 |         $delayed = new Delayed();
141 | 
142 |         \eio_read(
143 |             $this->handle,
144 |             $length,
145 |             $this->position,
146 |             null,
147 |             function (Delayed $delayed, $result, $req) {
148 |                 if (-1 === $result) {
149 |                     $delayed->reject(new FileException(
150 |                         sprintf('Reading from file failed: %s.', \eio_get_last_error($req))
151 |                     ));
152 |                 } else {
153 |                     $delayed->resolve($result);
154 |                 }
155 |             },
156 |             $delayed
157 |         );
158 | 
159 |         $this->poll->listen();
160 | 
161 |         if ($timeout) {
162 |             $delayed = $delayed->timeout($timeout);
163 |         }
164 | 
165 |         try {
166 |             $data = yield $delayed;
167 |         } finally {
168 |             $this->poll->done();
169 |         }
170 | 
171 |         $byte = strlen($byte) ? $byte[0] : null;
172 | 
173 |         if (null !== $byte && false !== ($position = strpos($data, $byte))) {
174 |             $data = substr($data, 0, $position + 1);
175 |         }
176 | 
177 |         $this->position += strlen($data);
178 | 
179 |         return $data;
180 |     }
181 | 
182 |     /**
183 |      * {@inheritdoc}
184 |      */
185 |     public function isReadable(): bool
186 |     {
187 |         return $this->isOpen() && !$this->eof();
188 |     }
189 | 
190 |     /**
191 |      * {@inheritdoc}
192 |      */
193 |     public function write(string $data, float $timeout = 0): \Generator
194 |     {
195 |         return $this->send($data, $timeout, false);
196 |     }
197 | 
198 |     /**
199 |      * {@inheritdoc}
200 |      */
201 |     public function end(string $data = '', float $timeout = 0): \Generator
202 |     {
203 |         return $this->send($data, $timeout, true);
204 |     }
205 | 
206 |     /**
207 |      * @coroutine
208 |      *
209 |      * @param string $data
210 |      * @param float|int $timeout
211 |      * @param bool $end
212 |      *
213 |      * @return \Generator
214 |      *
215 |      * @resolve int Number of bytes written to the file.
216 |      *
217 |      * @throws \Icicle\Stream\Exception\UnwritableException
218 |      */
219 |     protected function send(string $data, float $timeout, bool $end = false): \Generator
220 |     {
221 |         if (!$this->isWritable()) {
222 |             throw new UnwritableException('The file is no longer writable.');
223 |         }
224 | 
225 |         if ($this->queue->isEmpty()) {
226 |             $awaitable = $this->push($data);
227 |         } else {
228 |             $awaitable = $this->queue->top();
229 |             $awaitable = $awaitable->then(function () use ($data) {
230 |                 return $this->push($data);
231 |             });
232 |         }
233 | 
234 |         $this->queue->push($awaitable);
235 | 
236 |         if ($end) {
237 |             $this->writable = false;
238 |         }
239 | 
240 |         if ($timeout) {
241 |             $awaitable = $awaitable->timeout($timeout);
242 |         }
243 | 
244 |         $this->poll->listen();
245 | 
246 |         try {
247 |             $result = yield $awaitable;
248 |         } catch (\Exception $exception) {
249 |             $this->close();
250 |             throw $exception;
251 |         } finally {
252 |             if ($end) {
253 |                 $this->close();
254 |             }
255 |             $this->poll->done();
256 |         }
257 | 
258 |         return $result;
259 |     }
260 | 
261 |     /**
262 |      * @param string $data
263 |      *
264 |      * @return \Icicle\Awaitable\Delayed
265 |      *
266 |      * @throws \Icicle\File\Exception\FileException
267 |      */
268 |     private function push(string $data): Awaitable
269 |     {
270 |         $length = strlen($data);
271 |         $delayed = new Delayed();
272 |         \eio_write(
273 |             $this->handle,
274 |             $data,
275 |             $length,
276 |             $this->append ? $this->size : $this->position,
277 |             null,
278 |             function (Delayed $delayed, $result, $req) use ($length) {
279 |                 if (-1 === $result) {
280 |                     $delayed->reject(new FileException(
281 |                         sprintf('Writing to the file failed: %s.', \eio_get_last_error($req))
282 |                     ));
283 |                 } elseif ($this->queue->isEmpty()) {
284 |                     $delayed->reject(new FileException('No pending write, the file may have been closed.'));
285 |                 } else {
286 |                     $this->queue->shift();
287 | 
288 |                     if ($this->append) {
289 |                         $this->size += $result;
290 |                     } else {
291 |                         $this->position += $result;
292 |                         if ($this->position > $this->size) {
293 |                             $this->size = $this->position;
294 |                         }
295 |                     }
296 | 
297 |                     $delayed->resolve($result);
298 |                 }
299 |             },
300 |             $delayed
301 |         );
302 | 
303 |         return $delayed;
304 |     }
305 | 
306 |     /**
307 |      * {@inheritdoc}
308 |      */
309 |     public function isWritable(): bool
310 |     {
311 |         return $this->writable;
312 |     }
313 | 
314 |     /**
315 |      * {@inheritdoc}
316 |      */
317 |     public function seek(int $offset, int $whence = \SEEK_SET, float $timeout = 0): \Generator
318 |     {
319 |         if (!$this->isOpen()) {
320 |             throw new UnseekableException('The file is no longer seekable.');
321 |         }
322 | 
323 |         switch ($whence) {
324 |             case \SEEK_SET:
325 |                 break;
326 | 
327 |             case \SEEK_CUR:
328 |                 $offset = $this->position + $offset;
329 |                 break;
330 | 
331 |             case \SEEK_END:
332 |                 $offset = $this->size + $offset;
333 |                 break;
334 | 
335 |             default:
336 |                 throw new InvalidArgumentError('Invalid whence value. Use SEEK_SET, SEEK_CUR, or SEEK_END.');
337 |         }
338 | 
339 |         if (0 > $offset) {
340 |             throw new OutOfBoundsException(sprintf('Invalid offset: %s.', $offset));
341 |         }
342 | 
343 |         $this->position = $offset;
344 | 
345 |         if ($this->position > $this->size) {
346 |             $this->size = $this->position;
347 |         }
348 | 
349 |         return $this->position;
350 | 
351 |         yield; // Unreachable, but makes method a coroutine.
352 |     }
353 | 
354 |     /**
355 |      * {@inheritdoc}
356 |      */
357 |     public function tell(): int
358 |     {
359 |         return $this->position;
360 |     }
361 | 
362 |     /**
363 |      * {@inheritdoc}
364 |      */
365 |     public function getLength(): int
366 |     {
367 |         return $this->size;
368 |     }
369 | 
370 |     /**
371 |      * {@inheritdoc}
372 |      */
373 |     public function truncate(int $size): \Generator
374 |     {
375 |         if (!$this->isOpen()) {
376 |             throw new FileException('The file has been closed.');
377 |         }
378 | 
379 |         if (0 >= $size) {
380 |             $size = 0;
381 |         }
382 | 
383 |         $delayed = new Delayed();
384 |         \eio_ftruncate($this->handle, $size, null, function (Delayed $delayed, $result, $req) {
385 |             if (-1 === $result) {
386 |                 $delayed->reject(new FileException(
387 |                     sprintf('Truncating the file failed: %s.', \eio_get_last_error($req))
388 |                 ));
389 |             } else {
390 |                 $delayed->resolve(true);
391 |             }
392 |         }, $delayed);
393 | 
394 |         $this->poll->listen();
395 | 
396 |         try {
397 |             $result = yield $delayed;
398 | 
399 |             $this->size = $size;
400 |             if ($this->position > $size) {
401 |                 $this->position = $size;
402 |             }
403 |         } finally {
404 |             $this->poll->done();
405 |         }
406 | 
407 |         return $result;
408 |     }
409 | 
410 |     /**
411 |      * {@inheritdoc}
412 |      */
413 |     public function stat(): \Generator
414 |     {
415 |         if (!$this->isOpen()) {
416 |             throw new FileException('The file has been closed.');
417 |         }
418 | 
419 |         $delayed = new Delayed();
420 |         \eio_fstat($this->handle, null, function (Delayed $delayed, $result, $req) {
421 |             if (-1 === $result) {
422 |                 $delayed->reject(new FileException(
423 |                     sprintf('Getting file status failed: %s.', \eio_get_last_error($req))
424 |                 ));
425 |             } else {
426 |                 $delayed->resolve($result);
427 |             }
428 |         }, $delayed);
429 | 
430 |         $this->poll->listen();
431 | 
432 |         try {
433 |             $stat = yield $delayed;
434 |         } finally {
435 |             $this->poll->done();
436 |         }
437 | 
438 |         $numeric = [];
439 |         foreach (EioDriver::getStatKeys() as $key => $name) {
440 |             $numeric[$key] = $stat[$name];
441 |         }
442 | 
443 |         return array_merge($numeric, $stat);
444 |     }
445 | 
446 |     /**
447 |      * {@inheritdoc}
448 |      */
449 |     public function chown(int $uid): \Generator
450 |     {
451 |         return $this->chowngrp($uid, -1);
452 |     }
453 | 
454 |     /**
455 |      * {@inheritdoc}
456 |      */
457 |     public function chgrp(int $gid): \Generator
458 |     {
459 |         return $this->chowngrp(-1, $gid);
460 |     }
461 | 
462 |     /**
463 |      * @coroutine
464 |      *
465 |      * @param int $uid
466 |      * @param int $gid
467 |      *
468 |      * @return \Generator
469 |      *
470 |      * @resolve bool
471 |      *
472 |      * @throws \Icicle\File\Exception\FileException
473 |      */
474 |     private function chowngrp(int $uid, int $gid): \Generator
475 |     {
476 |         if (!$this->isOpen()) {
477 |             throw new FileException('The file has been closed.');
478 |         }
479 | 
480 |         $delayed = new Delayed();
481 |         \eio_fchown($this->handle, $uid, $gid, null, function (Delayed $delayed, $result, $req) {
482 |             if (-1 === $result) {
483 |                 $delayed->reject(new FileException(
484 |                     sprintf('Changing the file owner or group failed: %s.', \eio_get_last_error($req))
485 |                 ));
486 |             } else {
487 |                 $delayed->resolve(true);
488 |             }
489 |         }, $delayed);
490 | 
491 |         $this->poll->listen();
492 | 
493 |         try {
494 |             $result = yield $delayed;
495 |         } finally {
496 |             $this->poll->done();
497 |         }
498 | 
499 |         return $result;
500 |     }
501 | 
502 |     /**
503 |      * {@inheritdoc}
504 |      */
505 |     public function chmod(int $mode): \Generator
506 |     {
507 |         if (!$this->isOpen()) {
508 |             throw new FileException('The file has been closed.');
509 |         }
510 | 
511 |         $delayed = new Delayed();
512 |         \eio_fchmod($this->handle, $mode, null, function (Delayed $delayed, $result, $req) {
513 |             if (-1 === $result) {
514 |                 $delayed->reject(new FileException(
515 |                     sprintf('Changing the file mode failed: %s.', \eio_get_last_error($req))
516 |                 ));
517 |             } else {
518 |                 $delayed->resolve(true);
519 |             }
520 |         }, $delayed);
521 | 
522 |         $this->poll->listen();
523 | 
524 |         try {
525 |             $result = yield $delayed;
526 |         } finally {
527 |             $this->poll->done();
528 |         }
529 | 
530 |         return $result;
531 |     }
532 | 
533 |     /**
534 |      * @coroutine
535 |      *
536 |      * @param string $path
537 |      *
538 |      * @return \Generator
539 |      *
540 |      * @resolve int
541 |      */
542 |     public function copy(string $path): \Generator
543 |     {
544 |         $delayed = new Delayed();
545 |         \eio_open(
546 |             $path,
547 |             \EIO_O_WRONLY | \EIO_O_CREAT | \EIO_O_TRUNC,
548 |             0644,
549 |             null,
550 |             function (Delayed $delayed, $handle, $req) {
551 |                 if (-1 === $handle) {
552 |                     $delayed->reject(new FileException(
553 |                         sprintf('Opening the file failed: %s.', \eio_get_last_error($req))
554 |                     ));
555 |                 } else {
556 |                     $delayed->resolve($handle);
557 |                 }
558 |             },
559 |             $delayed
560 |         );
561 | 
562 |         $this->poll->listen();
563 | 
564 |         try {
565 |             $handle = yield $delayed;
566 |         } finally {
567 |             $this->poll->done();
568 |         }
569 | 
570 |         $delayed = new Delayed();
571 |         \eio_sendfile(
572 |             $handle,
573 |             $this->handle,
574 |             0,
575 |             $this->size,
576 |             null,
577 |             function (Delayed $delayed, $result, $req) {
578 |                 if (-1 === $result) {
579 |                     $delayed->reject(new FileException(
580 |                         sprintf('Copying the file failed: %s.', \eio_get_last_error($req))
581 |                     ));
582 |                 } else {
583 |                     $delayed->resolve(true);
584 |                 }
585 |             },
586 |             $delayed
587 |         );
588 | 
589 |         $this->poll->listen();
590 | 
591 |         try {
592 |             yield $delayed;
593 |         } finally {
594 |             $this->poll->done();
595 |             \eio_close($handle);
596 |         }
597 | 
598 |         return $this->size;
599 |     }
600 | }
601 | 


--------------------------------------------------------------------------------
/src/Eio/Internal/EioPoll.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Icicle\File\Eio\Internal;
 3 | 
 4 | use Icicle\Loop;
 5 | use Icicle\Loop\Watcher\Io;
 6 | 
 7 | class EioPoll
 8 | {
 9 |     /**
10 |      * @var \Icicle\Loop\Watcher\Io
11 |      */
12 |     private $poll;
13 | 
14 |     /**
15 |      * @var int
16 |      */
17 |     private $requests = 0;
18 | 
19 |     public function __construct()
20 |     {
21 |         \eio_init();
22 |         $this->poll = $this->createPoll();
23 |     }
24 | 
25 |     public function listen()
26 |     {
27 |         if (0 === $this->requests++) {
28 |             if ($this->poll->isFreed()) {
29 |                 \eio_init();
30 |                 $this->poll = $this->createPoll();
31 |             }
32 | 
33 |             $this->poll->listen();
34 |         }
35 |     }
36 | 
37 |     public function done()
38 |     {
39 |         if (0 === --$this->requests) {
40 |             $this->poll->cancel();
41 |         }
42 |     }
43 | 
44 |     public function __destruct()
45 |     {
46 |         $this->poll->free();
47 |     }
48 | 
49 |     private function createPoll(): Io
50 |     {
51 |         return Loop\poll(\eio_get_event_stream(), function () {
52 |             while (\eio_npending()) {
53 |                 \eio_poll();
54 |             }
55 |         }, true);
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/Exception/Error.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Icicle\File\Exception;
3 | 
4 | interface Error extends \Icicle\Exception\Error, Throwable {}
5 | 


--------------------------------------------------------------------------------
/src/Exception/Exception.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Icicle\File\Exception;
3 | 
4 | interface Exception extends \Icicle\Exception\Exception, Throwable {}
5 | 


--------------------------------------------------------------------------------
/src/Exception/FileException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Icicle\File\Exception;
 3 | 
 4 | class FileException extends \Exception implements Exception
 5 | {
 6 |     public function __construct($message, \Exception $previous = null)
 7 |     {
 8 |         parent::__construct($message, 0, $previous);
 9 |     }
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/src/Exception/Throwable.php:
--------------------------------------------------------------------------------
1 | <?php
2 | namespace Icicle\File\Exception;
3 | 
4 | interface Throwable extends \Icicle\Exception\Throwable {}
5 | 


--------------------------------------------------------------------------------
/src/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | namespace Icicle\File;
 3 | 
 4 | use Icicle\Stream\{DuplexStream, SeekableStream};
 5 | 
 6 | interface File extends DuplexStream, SeekableStream
 7 | {
 8 |     const CHUNK_SIZE = 8192;
 9 | 
10 |     /**
11 |      * Returns the path used to open the file.
12 |      *
13 |      * @return string
14 |      */
15 |     public function getPath(): string;
16 | 
17 |     /**
18 |      * @return bool
19 |      */
20 |     public function eof(): bool;
21 | 
22 |     /**
23 |      * @coroutine
24 |      *
25 |      * @return \Generator
26 |      *
27 |      * @resolve array
28 |      *
29 |      * @throws \Icicle\File\Exception\FileException
30 |      */
31 |     public function stat(): \Generator;
32 | 
33 |     /**
34 |      * @coroutine
35 |      *
36 |      * @param int $size
37 |      *
38 |      * @return \Generator
39 |      *
40 |      * @resolve bool
41 |      *
42 |      * @throws \Icicle\File\Exception\FileException
43 |      */
44 |     public function truncate(int $size): \Generator;
45 | 
46 |     /**
47 |      * @coroutine
48 |      *
49 |      * @param string $path
50 |      *
51 |      * @return \Generator
52 |      *
53 |      * @resolve int Size of copied file.
54 |      *
55 |      * @throws \Icicle\File\Exception\FileException
56 |      */
57 |     public function copy(string $path): \Generator;
58 | 
59 |     /**
60 |      * @coroutine
61 |      *
62 |      * @param int $uid
63 |      *
64 |      * @return \Generator
65 |      *
66 |      * @resolve bool
67 |      *
68 |      * @throws \Icicle\File\Exception\FileException
69 |      */
70 |     public function chown(int $uid): \Generator;
71 | 
72 |     /**
73 |      * @coroutine
74 |      *
75 |      * @param int $gid
76 |      *
77 |      * @return \Generator
78 |      *
79 |      * @resolve bool
80 |      *
81 |      * @throws \Icicle\File\Exception\FileException
82 |      */
83 |     public function chgrp(int $gid): \Generator;
84 | 
85 |     /**
86 |      * @coroutine
87 |      *
88 |      * @param int $mode
89 |      *
90 |      * @return \Generator
91 |      *
92 |      * @resolve bool
93 |      *
94 |      * @throws \Icicle\File\Exception\FileException
95 |      */
96 |     public function chmod(int $mode): \Generator;
97 | }
98 | 


--------------------------------------------------------------------------------
/src/functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | namespace Icicle\File;
  3 | 
  4 | use Icicle\File\{Concurrent\ConcurrentDriver, Eio\EioDriver};
  5 | 
  6 | if (!\function_exists(__NAMESPACE__ . '\driver')) {
  7 |     /**
  8 |      * @param \Icicle\File\Driver|null $driver
  9 |      *
 10 |      * @return \Icicle\File\Driver
 11 |      */
 12 |     function driver(Driver $driver = null): Driver
 13 |     {
 14 |         static $instance;
 15 | 
 16 |         if (null !== $driver) {
 17 |             $instance = $driver;
 18 |         } elseif (null === $instance) {
 19 |             $instance = create();
 20 |         }
 21 | 
 22 |         return $instance;
 23 |     }
 24 | 
 25 |     /**
 26 |      * @return \Icicle\File\Driver
 27 |      *
 28 |      * @codeCoverageIgnore
 29 |      */
 30 |     function create(): Driver
 31 |     {
 32 |         if (EioDriver::enabled()) {
 33 |             return new EioDriver();
 34 |         }
 35 | 
 36 |         return new ConcurrentDriver();
 37 |     }
 38 | 
 39 |     /**
 40 |      * @coroutine
 41 |      *
 42 |      * @param string $path
 43 |      *
 44 |      * @return \Generator
 45 |      *
 46 |      * @resolve string File contents.
 47 |      *
 48 |      * @throws \Icicle\File\Exception\FileException
 49 |      */
 50 |     function get(string $path): \Generator
 51 |     {
 52 |         /** @var \Icicle\File\File $file */
 53 |         $file = yield from open($path, 'r');
 54 | 
 55 |         $data = '';
 56 | 
 57 |         try {
 58 |             while (!$file->eof()) {
 59 |                 $data .= yield from $file->read();
 60 |             }
 61 |         } finally {
 62 |             $file->close();
 63 |         }
 64 | 
 65 |         return $data;
 66 |     }
 67 | 
 68 |     /**
 69 |      * @coroutine
 70 |      *
 71 |      * @param string $path
 72 |      * @param string $data
 73 |      * @param bool $append
 74 |      *
 75 |      * @return \Generator
 76 |      *
 77 |      * @resolve int Number of bytes written.
 78 |      *
 79 |      * @throws \Icicle\File\Exception\FileException
 80 |      */
 81 |     function put(string $path, string $data, bool $append = false): \Generator
 82 |     {
 83 |         /** @var \Icicle\File\File $file */
 84 |         $file = yield from open($path, $append ? 'a' : 'w');
 85 | 
 86 |         try {
 87 |             $written = yield from $file->write($data);
 88 |         } finally {
 89 |             $file->close();
 90 |         }
 91 | 
 92 |         return $written;
 93 |     }
 94 | 
 95 |     /**
 96 |      * Opens the file at the file path using the given mode. Modes are identical to those of fopen().
 97 |      *
 98 |      * @coroutine
 99 |      *
100 |      * @param string $path
101 |      * @param string $mode
102 |      *
103 |      * @return \Generator
104 |      *
105 |      * @resolve \Icicle\File\File
106 |      *
107 |      * @throws \Icicle\File\Exception\FileException If the file is not found or cannot be opened.
108 |      */
109 |     function open(string $path, string $mode): \Generator
110 |     {
111 |         return driver()->open($path, $mode);
112 |     }
113 | 
114 |     /**
115 |      * @coroutine
116 |      *
117 |      * @param string $path
118 |      *
119 |      * @return \Generator
120 |      *
121 |      * @resolve bool
122 |      *
123 |      * @throws \Icicle\File\Exception\FileException If unlinking the file fails.
124 |      */
125 |     function unlink(string $path): \Generator
126 |     {
127 |         return driver()->unlink($path);
128 |     }
129 | 
130 |     /**
131 |      * @coroutine
132 |      *
133 |      * @param string $path
134 |      *
135 |      * @return \Generator
136 |      *
137 |      * @resolve array
138 |      *
139 |      * @throws \Icicle\File\Exception\FileException If getting the file stats fails.
140 |      */
141 |     function stat(string $path): \Generator
142 |     {
143 |         return driver()->stat($path);
144 |     }
145 | 
146 |     /**
147 |      * @coroutine
148 |      *
149 |      * @param string $oldPath
150 |      * @param string $newPath
151 |      *
152 |      * @return \Generator
153 |      *
154 |      * @resolve bool
155 |      *
156 |      * @throws \Icicle\File\Exception\FileException If renaming the file fails.
157 |      */
158 |     function rename(string $oldPath, string $newPath): \Generator
159 |     {
160 |         return driver()->rename($oldPath, $newPath);
161 |     }
162 | 
163 |     /**
164 |      * @coroutine
165 |      *
166 |      * @param string $source
167 |      * @param string $target
168 |      *
169 |      * @return \Generator
170 |      *
171 |      * @resolve bool
172 |      *
173 |      * @throws \Icicle\File\Exception\FileException If creating the hard link fails.
174 |      */
175 |     function link(string $source, string $target): \Generator
176 |     {
177 |         return driver()->link($source, $target);
178 |     }
179 | 
180 |     /**
181 |      * @coroutine
182 |      *
183 |      * @param string $path
184 |      *
185 |      * @return \Generator
186 |      *
187 |      * @resolve bool
188 |      *
189 |      * @throws \Icicle\File\Exception\FileException If reading the symlink fails.
190 |      */
191 |     function readlink(string $path): \Generator
192 |     {
193 |         return driver()->readlink($path);
194 |     }
195 | 
196 |     /**
197 |      * @coroutine
198 |      *
199 |      * @param string $source
200 |      * @param string $target
201 |      *
202 |      * @return \Generator
203 |      *
204 |      * @resolve bool
205 |      *
206 |      * @throws \Icicle\File\Exception\FileException If creating the symlink fails.
207 |      */
208 |     function symlink(string $source, string $target): \Generator
209 |     {
210 |         return driver()->symlink($source, $target);
211 |     }
212 | 
213 |     /**
214 |      * @coroutine
215 |      *
216 |      * @param string $source
217 |      * @param string $target
218 |      *
219 |      * @return \Generator
220 |      *
221 |      * @resolve int Size of copied file.
222 |      *
223 |      * @throws \Icicle\File\Exception\FileException If copying the file fails.
224 |      */
225 |     function copy(string $source, string $target): \Generator
226 |     {
227 |         return driver()->copy($source, $target);
228 |     }
229 | 
230 |     /**
231 |      * @coroutine
232 |      *
233 |      * @param string $path
234 |      *
235 |      * @return \Generator
236 |      *
237 |      * @resolve bool
238 |      *
239 |      * @throws \Icicle\File\Exception\FileException If determining if the path is a file fails.
240 |      */
241 |     function isFile(string $path): \Generator
242 |     {
243 |         return driver()->isFile($path);
244 |     }
245 | 
246 |     /**
247 |      * @coroutine
248 |      *
249 |      * @param string $path
250 |      *
251 |      * @return \Generator
252 |      *
253 |      * @resolve bool
254 |      *
255 |      * @throws \Icicle\File\Exception\FileException If determining if the path is a directory fails.
256 |      */
257 |     function isDir(string $path): \Generator
258 |     {
259 |         return driver()->isDir($path);
260 |     }
261 | 
262 |     /**
263 |      * @coroutine
264 |      *
265 |      * @param string $path
266 |      * @param int $mode
267 |      *
268 |      * @return \Generator
269 |      *
270 |      * @resolve bool
271 |      */
272 |     function mkDir(string $path, int $mode = 0755): \Generator
273 |     {
274 |         return driver()->mkDir($path, $mode);
275 |     }
276 | 
277 |     /**
278 |      * @coroutine
279 |      *
280 |      * @param $path
281 |      *
282 |      * @return \Generator
283 |      *
284 |      * @resolve string[]
285 |      */
286 |     function lsDir(string $path): \Generator
287 |     {
288 |         return driver()->lsDir($path);
289 |     }
290 | 
291 |     /**
292 |      * @coroutine
293 |      *
294 |      * @param $path
295 |      *
296 |      * @return \Generator
297 |      *
298 |      * @resolve bool
299 |      */
300 |     function rmDir(string $path): \Generator
301 |     {
302 |         return driver()->rmDir($path);
303 |     }
304 | 
305 |     /**
306 |      * @coroutine
307 |      *
308 |      * @param string $path
309 |      * @param int $uid
310 |      *
311 |      * @return \Generator
312 |      *
313 |      * @resolve bool
314 |      */
315 |     function chown(string $path, int $uid): \Generator
316 |     {
317 |         return driver()->chown($path, $uid);
318 |     }
319 | 
320 |     /**
321 |      * @coroutine
322 |      *
323 |      * @param string $path
324 |      * @param int $gid
325 |      *
326 |      * @return \Generator
327 |      *
328 |      * @resolve bool
329 |      */
330 |     function chgrp(string $path, int $gid): \Generator
331 |     {
332 |         return driver()->chgrp($path, $gid);
333 |     }
334 | 
335 |     /**
336 |      * @coroutine
337 |      *
338 |      * @param string $path
339 |      * @param int $mode
340 |      *
341 |      * @return \Generator
342 |      *
343 |      * @resolve bool
344 |      */
345 |     function chmod(string $path, int $mode): \Generator
346 |     {
347 |         return driver()->chmod($path, $mode);
348 |     }
349 | }
350 | 


--------------------------------------------------------------------------------