PiedWeb\CMSBundle\Service\MediaCacheGeneratorService

Complexity

Total Complexity

15

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	createWebP()	0	8	1
A	imgToWebPStatic()	0	13	2
A	storeImageInCacheStatic()	0	11	2
A	__construct()	0	10	1
A	imgToWebP()	0	11	1
A	getBinary()	0	9	2
A	generateCache()	0	18	2
A	createWebPStatic()	0	9	2
A	storeImageInCache()	0	11	2

<?php

namespace PiedWeb\CMSBundle\Service;

use Liip\ImagineBundle\Exception\Binary\Loader\NotLoadableException;
use Liip\ImagineBundle\Imagine\Cache\CacheManager;
use Liip\ImagineBundle\Imagine\Data\DataManager;
use Liip\ImagineBundle\Imagine\Filter\FilterManager;
use PiedWeb\CMSBundle\Entity\MediaInterface;
//use WebPConvert\Convert\Converters\Stack as WebPConverter;
use Spatie\Async\Pool;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

class MediaCacheGeneratorService
{
    protected $projectDir;
    protected $pool;
    protected $cacheManager;
    protected $filterManager;
    protected $dataManager;

    protected static $webPConverterOptions = [
        'converters' => ['cwebp'],
        //'try-cwebp'  => false,
        //'converters' => ['cwebp', 'gd', 'vips', 'imagick', 'gmagick', 'imagemagick', 'graphicsmagick', 'wpc', 'ewww'],
    ];

    public function __construct(
        string $projectDir,
        CacheManager $cacheManager,
        DataManager $dataManager,
        FilterManager $filterManager
    ) {
        $this->projectDir = $projectDir;
        $this->cacheManager = $cacheManager;
        $this->dataManager = $dataManager;
        $this->filterManager = $filterManager;
    }

    public function generateCache(MediaInterface $media)
    {
        $this->pool = Pool::create();

        $this->createWebP($media); // do i need it ?! Yes, if the generation failed, liip will use this one

        $path = '/'.$media->getRelativeDir().'/'.$media->getMedia();
        $binary = $this->getBinary($path);
        //$pathWebP = '/'.$media->getRelativeDir().'/'.$media->getSlug().'.webp';

        $filters = array_keys($this->filterManager->getFilterConfiguration()->all());

        foreach ($filters as $filter) {
            $this->storeImageInCache($path, $binary, $filter);
            $this->imgToWebP($media, $filter);
            //$this->storeImageInCache($pathWebP, $binary, $filter); liip not optimized...
        }
        $this->pool->wait();
    }

    public function getBinary($path)
    {
        try {
            $binary = $this->dataManager->find('default', $path);
        } catch (NotLoadableException $e) {
            throw new NotFoundHttpException('Source image could not be found', $e);
        }

        return $binary;
    }

    public function storeImageInCache($path, $binary, $filter): void
    {
        try {
            $this->cacheManager->store(
                $this->filterManager->applyFilter($binary, $filter),
                $path,
                $filter
            );
        } catch (\RuntimeException $e) {
            $msg = 'Unable to create image for path "%s" and filter "%s". '.'Message was "%s"';
            throw new \RuntimeException(sprintf($msg, $path, $filter, $e->getMessage()), 0, $e);
        }
    }

    /**
     * Todo: test the win to generate liip in multithread.
     */
    public static function storeImageInCacheStatic($path, $binary, $filter, $cacheManager, $filterManager): void
    {
        try {
            $cacheManager->store(
                $filterManager->applyFilter($binary, $filter),
                $path,
                $filter
            );
        } catch (\RuntimeException $e) {
            $msg = 'Unable to create image for path "%s" and filter "%s". '.'Message was "%s"';
            throw new \RuntimeException(sprintf($msg, $path, $filter, $e->getMessage()), 0, $e);
        }
    }

    public static function imgToWebPStatic($path, $webPPath, $webPConverterOptions, string $filter): void
    {
        $webPConverter = new WebPConverter(
            $path,
            $webPPath,
            $webPConverterOptions
        );

        try {
            $webPConverter->doConvert();
        } catch (\Exception $e) {
            $msg = 'Unable to create image for path "%s" and filter "%s". '.'Message was "%s"';
            throw new \RuntimeException(sprintf($msg, $path, $filter, $e->getMessage()), 0, $e);
        }
    }

    /**
     * Use the liip generated filter to generate the webp equivalent.
     */
    public function imgToWebP(MediaInterface $media, string $filter): void
    {
        $pathJpg = $this->projectDir.'/public/'.$media->getRelativeDir().'/'.$filter.'/'.$media->getMedia();
        $pathWebP = $this->projectDir.'/public/'.$media->getRelativeDir().'/'.$filter.'/'.$media->getSlug().'.webp';
        $webPConverterOptions = self::$webPConverterOptions;

        $this->pool->add(function () use ($pathJpg, $pathWebP, $webPConverterOptions, $filter) {
            // took 46s (vs 43s) to add liip generation in async
            //exec($projectDir.'/bin/console liip:imagine:cache:resolve "'.$path.'" --force --filter='.$filter
            //.' >/dev/null 2>&1 &');
            self::imgToWebPStatic($pathJpg, $pathWebP, $webPConverterOptions, $filter);
        });
    }

    public function createWebP(MediaInterface $media): void
    {
        $destination = $this->projectDir.'/'.$media->getRelativeDir().'/'.$media->getSlug().'.webp';
        $source = $this->projectDir.$media->getPath();
        //self::createWebPStatic($destination, $source);

        $this->pool->add(function () use ($destination, $source) {
            self::createWebPStatic($destination, $source);
        });
    }

    public static function createWebPStatic($destination, $source): void
    {
        $webPConverter = new WebPConverter($source, $destination, self::$webPConverterOptions);

        try {
            $webPConverter->doConvert();
        } catch (\Exception $e) {
            $msg = 'Unable to create image for path "%s" and filter "%s". '.'Message was "%s"';
            throw new \RuntimeException(sprintf($msg, $source, 'importing from img', $e->getMessage()), 0, $e);
        }
    }
}