Completed
Push — master ( 66d197...72430f )
by Jonathan
03:30
created

Server::__construct()   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 6

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 5
CRAP Score 1

Importance

Changes 0
Metric Value
dl 0
loc 6
ccs 5
cts 5
cp 1
rs 10
c 0
b 0
f 0
cc 1
nc 1
nop 3
crap 1
1
<?php
2
3
namespace League\Glide;
4
5
use InvalidArgumentException;
6
use League\Flysystem\FileExistsException;
7
use League\Flysystem\FilesystemInterface;
8
use League\Glide\Api\ApiInterface;
9
use League\Glide\Filesystem\FileNotFoundException;
10
use League\Glide\Filesystem\FilesystemException;
11
use League\Glide\Responses\ResponseFactoryInterface;
12
13
class Server
14
{
15
    /**
16
     * Source file system.
17
     * @var FilesystemInterface
18
     */
19
    protected $source;
20
21
    /**
22
     * Source path prefix.
23
     * @var string
24
     */
25
    protected $sourcePathPrefix;
26
27
    /**
28
     * Cache file system.
29
     * @var FilesystemInterface
30
     */
31
    protected $cache;
32
33
    /**
34
     * Cache path prefix.
35
     * @var string
36
     */
37
    protected $cachePathPrefix;
38
39
    /**
40
     * Whether to group cache in folders.
41
     * @var bool
42
     */
43
    protected $groupCacheInFolders = true;
44
45
    /**
46
     * Whether to cache with file extensions.
47
     * @var bool
48
     */
49
    protected $cacheWithFileExtensions = false;
50
51
    /**
52
     * Image manipulation API.
53
     * @var ApiInterface
54
     */
55
    protected $api;
56
57
    /**
58
     * Response factory.
59
     * @var ResponseFactoryInterface|null
60
     */
61
    protected $responseFactory;
62
63
    /**
64
     * Base URL.
65
     * @var string
66
     */
67
    protected $baseUrl;
68
69
    /**
70
     * Default image manipulations.
71
     * @var array
72
     */
73
    protected $defaults = [];
74
75
    /**
76
     * Preset image manipulations.
77
     * @var array
78
     */
79
    protected $presets = [];
80
81
    /**
82
     * Create Server instance.
83
     * @param FilesystemInterface $source Source file system.
84
     * @param FilesystemInterface $cache  Cache file system.
85
     * @param ApiInterface        $api    Image manipulation API.
86
     */
87 171
    public function __construct(FilesystemInterface $source, FilesystemInterface $cache, ApiInterface $api)
88
    {
89 171
        $this->setSource($source);
90 171
        $this->setCache($cache);
91 171
        $this->setApi($api);
92 171
    }
93
94
    /**
95
     * Set source file system.
96
     * @param FilesystemInterface $source Source file system.
97
     */
98 171
    public function setSource(FilesystemInterface $source)
99
    {
100 171
        $this->source = $source;
101 171
    }
102
103
    /**
104
     * Get source file system.
105
     * @return FilesystemInterface Source file system.
106
     */
107 6
    public function getSource()
108
    {
109 6
        return $this->source;
110
    }
111
112
    /**
113
     * Set source path prefix.
114
     * @param string $sourcePathPrefix Source path prefix.
115
     */
116 15
    public function setSourcePathPrefix($sourcePathPrefix)
117
    {
118 15
        $this->sourcePathPrefix = trim($sourcePathPrefix, '/');
119 15
    }
120
121
    /**
122
     * Get source path prefix.
123
     * @return string Source path prefix.
124
     */
125 6
    public function getSourcePathPrefix()
126
    {
127 6
        return $this->sourcePathPrefix;
128
    }
129
130
    /**
131
     * Get source path.
132
     * @param  string                $path Image path.
133
     * @return string                The source path.
134
     * @throws FileNotFoundException
135
     */
136 87
    public function getSourcePath($path)
137
    {
138 87
        $path = trim($path, '/');
139
        
140 87
        $baseUrl = $this->baseUrl.'/';
141
142 87
        if (substr($path, 0, strlen($baseUrl)) === $baseUrl) {
143 3
            $path = trim(substr($path, strlen($baseUrl)), '/');
144 3
        }
145
146 87
        if ($path === '') {
147 3
            throw new FileNotFoundException('Image path missing.');
148
        }
149
150 84
        if ($this->sourcePathPrefix) {
151 6
            $path = $this->sourcePathPrefix.'/'.$path;
152 6
        }
153
154 84
        return rawurldecode($path);
155
    }
156
157
    /**
158
     * Check if a source file exists.
159
     * @param  string $path Image path.
160
     * @return bool   Whether the source file exists.
161
     */
162 18
    public function sourceFileExists($path)
163
    {
164 18
        return $this->source->has($this->getSourcePath($path));
165
    }
166
167
    /**
168
     * Set base URL.
169
     * @param string $baseUrl Base URL.
170
     */
171 12
    public function setBaseUrl($baseUrl)
172
    {
173 12
        $this->baseUrl = trim($baseUrl, '/');
174 12
    }
175
176
    /**
177
     * Get base URL.
178
     * @return string Base URL.
179
     */
180 6
    public function getBaseUrl()
181
    {
182 6
        return $this->baseUrl;
183
    }
184
185
    /**
186
     * Set cache file system.
187
     * @param FilesystemInterface $cache Cache file system.
188
     */
189 171
    public function setCache(FilesystemInterface $cache)
190
    {
191 171
        $this->cache = $cache;
192 171
    }
193
194
    /**
195
     * Get cache file system.
196
     * @return FilesystemInterface Cache file system.
197
     */
198 6
    public function getCache()
199
    {
200 6
        return $this->cache;
201
    }
202
203
    /**
204
     * Set cache path prefix.
205
     * @param string $cachePathPrefix Cache path prefix.
206
     */
207 12
    public function setCachePathPrefix($cachePathPrefix)
208
    {
209 12
        $this->cachePathPrefix = trim($cachePathPrefix, '/');
210 12
    }
211
212
    /**
213
     * Get cache path prefix.
214
     * @return string Cache path prefix.
215
     */
216 6
    public function getCachePathPrefix()
217
    {
218 6
        return $this->cachePathPrefix;
219
    }
220
221
    /**
222
     * Set the group cache in folders setting.
223
     * @param bool $groupCacheInFolders Whether to group cache in folders.
224
     */
225 15
    public function setGroupCacheInFolders($groupCacheInFolders)
226
    {
227 15
        $this->groupCacheInFolders = $groupCacheInFolders;
228 15
    }
229
230
    /**
231
     * Get the group cache in folders setting.
232
     * @return bool Whether to group cache in folders.
233
     */
234 6
    public function getGroupCacheInFolders()
235
    {
236 6
        return $this->groupCacheInFolders;
237
    }
238
239
    /**
240
     * Set the cache with file extensions setting.
241
     * @param bool $cacheWithFileExtensions Whether to cache with file extensions.
242
     */
243 30
    public function setCacheWithFileExtensions($cacheWithFileExtensions)
244
    {
245 30
        $this->cacheWithFileExtensions = $cacheWithFileExtensions;
246 30
    }
247
248
    /**
249
     * Get the cache with file extensions setting.
250
     * @return bool Whether to cache with file extensions.
251
     */
252 6
    public function getCacheWithFileExtensions()
253
    {
254 6
        return $this->cacheWithFileExtensions;
255
    }
256
257
    /**
258
     * Get cache path.
259
     * @param  string $path   Image path.
260
     * @param  array  $params Image manipulation params.
261
     * @return string Cache path.
262
     */
263 69
    public function getCachePath($path, array $params = [])
264
    {
265 69
        $sourcePath = $this->getSourcePath($path);
266
267 69
        if ($this->sourcePathPrefix) {
268 3
            $sourcePath = substr($sourcePath, strlen($this->sourcePathPrefix) + 1);
269 3
        }
270
271 69
        $params = $this->getAllParams($params);
272 69
        unset($params['s'], $params['p']);
273 69
        ksort($params);
274
275 69
        $md5 = md5($sourcePath.'?'.http_build_query($params));
276
277 69
        $cachedPath = $this->groupCacheInFolders ? $sourcePath.'/'.$md5 : $md5;
278
279 69
        if ($this->cachePathPrefix) {
280 3
            $cachedPath = $this->cachePathPrefix.'/'.$cachedPath;
281 3
        }
282
        
283 69
        if ($this->cacheWithFileExtensions) {
284 21
            $ext = (isset($params['fm']) ? $params['fm'] : pathinfo($path)['extension']);
285 21
            $ext = ($ext === 'pjpg') ? 'jpg' : $ext;
286 21
            $cachedPath .= '.'.$ext;
287 21
        }
288
289 69
        return $cachedPath;
290
    }
291
292
    /**
293
     * Check if a cache file exists.
294
     * @param  string $path   Image path.
295
     * @param  array  $params Image manipulation params.
296
     * @return bool   Whether the cache file exists.
297
     */
298 33
    public function cacheFileExists($path, array $params)
299
    {
300 33
        return $this->cache->has(
301 33
            $this->getCachePath($path, $params)
302 33
        );
303
    }
304
305
    /**
306
     * Delete cached manipulations for an image.
307
     * @param  string $path Image path.
308
     * @return bool   Whether the delete succeeded.
309
     */
310 6
    public function deleteCache($path)
311
    {
312 6
        if (!$this->groupCacheInFolders) {
313 3
            throw new InvalidArgumentException(
314
                'Deleting cached image manipulations is not possible when grouping cache into folders is disabled.'
315 3
            );
316
        }
317
318 3
        return $this->cache->deleteDir(
319 3
            dirname($this->getCachePath($path))
320 3
        );
321
    }
322
323
    /**
324
     * Set image manipulation API.
325
     * @param ApiInterface $api Image manipulation API.
326
     */
327 171
    public function setApi(ApiInterface $api)
328
    {
329 171
        $this->api = $api;
330 171
    }
331
332
    /**
333
     * Get image manipulation API.
334
     * @return ApiInterface Image manipulation API.
335
     */
336 6
    public function getApi()
337
    {
338 6
        return $this->api;
339
    }
340
341
    /**
342
     * Set default image manipulations.
343
     * @param array $defaults Default image manipulations.
344
     */
345 21
    public function setDefaults(array $defaults)
346
    {
347 21
        $this->defaults = $defaults;
348 21
    }
349
350
    /**
351
     * Get default image manipulations.
352
     * @return array Default image manipulations.
353
     */
354 6
    public function getDefaults()
355
    {
356 6
        return $this->defaults;
357
    }
358
359
    /**
360
     * Set preset image manipulations.
361
     * @param array $presets Preset image manipulations.
362
     */
363 21
    public function setPresets(array $presets)
364
    {
365 21
        $this->presets = $presets;
366 21
    }
367
368
    /**
369
     * Get preset image manipulations.
370
     * @return array Preset image manipulations.
371
     */
372 6
    public function getPresets()
373
    {
374 6
        return $this->presets;
375
    }
376
377
    /**
378
     * Get all image manipulations params, including defaults and presets.
379
     * @param  array $params Image manipulation params.
380
     * @return array All image manipulation params.
381
     */
382 72
    public function getAllParams(array $params)
383
    {
384 72
        $all = $this->defaults;
385
386 72
        if (isset($params['p'])) {
387 9
            foreach (explode(',', $params['p']) as $preset) {
388 9
                if (isset($this->presets[$preset])) {
389 9
                    $all = array_merge($all, $this->presets[$preset]);
390 9
                }
391 9
            }
392 9
        }
393
394 72
        return array_merge($all, $params);
395
    }
396
397
    /**
398
     * Set response factory.
399
     * @param ResponseFactoryInterface|null $responseFactory Response factory.
400
     */
401 15
    public function setResponseFactory(ResponseFactoryInterface $responseFactory = null)
402
    {
403 15
        $this->responseFactory = $responseFactory;
404 15
    }
405
406
    /**
407
     * Get response factory.
408
     * @return ResponseFactoryInterface Response factory.
409
     */
410 6
    public function getResponseFactory()
411
    {
412 6
        return $this->responseFactory;
413
    }
414
415
    /**
416
     * Generate and return image response.
417
     * @param  string                   $path   Image path.
418
     * @param  array                    $params Image manipulation params.
419
     * @return mixed                    Image response.
420
     * @throws InvalidArgumentException
421
     */
422 6
    public function getImageResponse($path, array $params)
423
    {
424 6
        if (is_null($this->responseFactory)) {
425 3
            throw new InvalidArgumentException(
426
                'Unable to get image response, no response factory defined.'
427 3
            );
428
        }
429
430 3
        $path = $this->makeImage($path, $params);
431
432 3
        return $this->responseFactory->create($this->cache, $path);
433
    }
434
435
    /**
436
     * Generate and return Base64 encoded image.
437
     * @param  string              $path   Image path.
438
     * @param  array               $params Image manipulation params.
439
     * @return string              Base64 encoded image.
440
     * @throws FilesystemException
441
     */
442 6
    public function getImageAsBase64($path, array $params)
443
    {
444 6
        $path = $this->makeImage($path, $params);
445
446 6
        $source = $this->cache->read($path);
447
448 6
        if ($source === false) {
449 3
            throw new FilesystemException(
450 3
                'Could not read the image `'.$path.'`.'
451 3
            );
452
        }
453
454 3
        return 'data:'.$this->cache->getMimetype($path).';base64,'.base64_encode($source);
455
    }
456
457
    /**
458
     * Generate and output image.
459
     * @param  string                   $path   Image path.
460
     * @param  array                    $params Image manipulation params.
461
     * @throws InvalidArgumentException
462
     */
463 3
    public function outputImage($path, array $params)
464
    {
465 3
        $path = $this->makeImage($path, $params);
466
467 3
        header('Content-Type:'.$this->cache->getMimetype($path));
468 3
        header('Content-Length:'.$this->cache->getSize($path));
469 3
        header('Cache-Control:'.'max-age=31536000, public');
470 3
        header('Expires:'.date_create('+1 years')->format('D, d M Y H:i:s').' GMT');
471
472 3
        $stream = $this->cache->readStream($path);
473
474 3
        if (ftell($stream) !== 0) {
475 3
            rewind($stream);
476 3
        }
477 3
        fpassthru($stream);
478 3
        fclose($stream);
479 3
    }
480
481
    /**
482
     * Generate manipulated image.
483
     * @param  string                $path   Image path.
484
     * @param  array                 $params Image manipulation params.
485
     * @return string                Cache path.
486
     * @throws FileNotFoundException
487
     * @throws FilesystemException
488
     */
489 30
    public function makeImage($path, array $params)
490
    {
491 30
        $sourcePath = $this->getSourcePath($path);
492 30
        $cachedPath = $this->getCachePath($path, $params);
493
494 30
        if ($this->cacheFileExists($path, $params) === true) {
495 15
            return $cachedPath;
496
        }
497
498 15
        if ($this->sourceFileExists($path) === false) {
499 3
            throw new FileNotFoundException(
500 3
                'Could not find the image `'.$sourcePath.'`.'
501 3
            );
502
        }
503
504 12
        $source = $this->source->read(
505
            $sourcePath
506 12
        );
507
508 12
        if ($source === false) {
509 3
            throw new FilesystemException(
510 3
                'Could not read the image `'.$sourcePath.'`.'
511 3
            );
512
        }
513
514
        // We need to write the image to the local disk before
515
        // doing any manipulations. This is because EXIF data
516
        // can only be read from an actual file.
517 9
        $tmp = tempnam(sys_get_temp_dir(), 'Glide');
518
519 9
        if (file_put_contents($tmp, $source) === false) {
520
            throw new FilesystemException(
521
                'Unable to write temp file for `'.$sourcePath.'`.'
522
            );
523
        }
524
525
        try {
526 9
            $write = $this->cache->write(
527 9
                $cachedPath,
528 9
                $this->api->run($tmp, $this->getAllParams($params))
529 9
            );
530
531 6
            if ($write === false) {
532 3
                throw new FilesystemException(
533 3
                    'Could not write the image `'.$cachedPath.'`.'
534 3
                );
535
            }
536 9
        } catch (FileExistsException $exception) {
537
            // This edge case occurs when the target already exists
538
            // because it's currently be written to disk in another
539
            // request. It's best to just fail silently.
540
        }
541
542 6
        unlink($tmp);
543
544 6
        return $cachedPath;
545
    }
546
}
547