vendor/knplabs/knp-snappy/src/Knp/Snappy/AbstractGenerator.php line 68

Open in your IDE?
  1. <?php
  3. namespace Knp\Snappy;
  5. use Knp\Snappy\Exception\FileAlreadyExistsException;
  6. use Psr\Log\LoggerAwareInterface;
  7. use Psr\Log\LoggerAwareTrait;
  8. use Symfony\Component\Process\Process;
  9. use Exception;
  10. use LogicException;
  11. use RuntimeException;
  12. use InvalidArgumentException;
  14. /**
  15.  * Base generator class for medias.
  16.  *
  17.  * @author  Matthieu Bontemps <matthieu.bontemps@knplabs.com>
  18.  * @author  Antoine Hérault <antoine.herault@knplabs.com>
  19.  */
  20. abstract class AbstractGenerator implements GeneratorInterface, LoggerAwareInterface
  21. {
  22.     use LoggerAwareTrait;
  24.     protected const ALLOWED_PROTOCOLS = ['file'];
  26.     protected const WINDOWS_LOCAL_FILENAME_REGEX = '/^[a-z]:(?:[\\\\\/]?(?:[\w\s!#()-]+|[\.]{1,2})+)*[\\\\\/]?/i';
  28.     /**
  29.      * @var array
  30.      */
  31.     public $temporaryFiles = [];
  33.     /**
  34.      * @var string
  35.      */
  36.     protected $temporaryFolder;
  38.     /**
  39.      * @var null|string
  40.      */
  41.     private $binary;
  43.     /**
  44.      * @var array
  45.      */
  46.     private $options = [];
  48.     /**
  49.      * @var null|array
  50.      */
  51.     private $env;
  53.     /**
  54.      * @var null|int
  55.      */
  56.     private $timeout;
  58.     /**
  59.      * @var string
  60.      */
  61.     private $defaultExtension;
  63.     /**
  64.      * @param null|string $binary
  65.      * @param array       $options
  66.      * @param null|array  $env
  67.      */
  68.     public function __construct($binary, array $options = [], array $env = null)
  69.     {
  70.         $this->configure();
  72.         $this->setBinary($binary);
  73.         $this->setOptions($options);
  74.         $this->env = empty($env) ? null : $env;
  76.         if (\is_callable([$this, 'removeTemporaryFiles'])) {
  77.             \register_shutdown_function([$this, 'removeTemporaryFiles']);
  78.         }
  79.     }
  81.     public function __destruct()
  82.     {
  83.         $this->removeTemporaryFiles();
  84.     }
  86.     /**
  87.      * Sets the default extension.
  88.      * Useful when letting Snappy deal with file creation.
  89.      *
  90.      * @param string $defaultExtension
  91.      *
  92.      * @return $this
  93.      */
  94.     public function setDefaultExtension($defaultExtension)
  95.     {
  96.         $this->defaultExtension = $defaultExtension;
  98.         return $this;
  99.     }
  101.     /**
  102.      * Gets the default extension.
  103.      *
  104.      * @return string
  105.      */
  106.     public function getDefaultExtension(): string
  107.     {
  108.         return $this->defaultExtension;
  109.     }
  111.     /**
  112.      * Sets an option. Be aware that option values are NOT validated and that
  113.      * it is your responsibility to validate user inputs.
  114.      *
  115.      * @param string $name  The option to set
  116.      * @param mixed  $value The value (NULL to unset)
  117.      *
  118.      * @throws InvalidArgumentException
  119.      *
  120.      * @return $this
  121.      */
  122.     public function setOption($name, $value)
  123.     {
  124.         if (!\array_key_exists($name, $this->options)) {
  125.             throw new InvalidArgumentException(\sprintf('The option \'%s\' does not exist.', $name));
  126.         }
  128.         $this->options[$name] = $value;
  130.         if (null !== $this->logger) {
  131.             $this->logger->debug(\sprintf('Set option "%s".', $name), ['value' => $value]);
  132.         }
  134.         return $this;
  135.     }
  137.     /**
  138.      * Sets the timeout.
  139.      *
  140.      * @param null|int $timeout The timeout to set
  141.      *
  142.      * @return $this
  143.      */
  144.     public function setTimeout($timeout)
  145.     {
  146.         $this->timeout = $timeout;
  148.         return $this;
  149.     }
  151.     /**
  152.      * Sets an array of options.
  153.      *
  154.      * @param array $options An associative array of options as name/value
  155.      *
  156.      * @return $this
  157.      */
  158.     public function setOptions(array $options)
  159.     {
  160.         foreach ($options as $name => $value) {
  161.             $this->setOption($name, $value);
  162.         }
  164.         return $this;
  165.     }
  167.     /**
  168.      * Returns all the options.
  169.      *
  170.      * @return array
  171.      */
  172.     public function getOptions()
  173.     {
  174.         return $this->options;
  175.     }
  177.     /**
  178.      * {@inheritdoc}
  179.      */
  180.     public function generate($input, $output, array $options = [], $overwrite = false)
  181.     {
  182.         $this->prepareOutput($output, $overwrite);
  184.         $command = $this->getCommand($input, $output, $options);
  186.         $inputFiles = \is_array($input) ? \implode('", "', $input) : $input;
  188.         if (null !== $this->logger) {
  189.             $this->logger->info(\sprintf('Generate from file(s) "%s" to file "%s".', $inputFiles, $output), [
  190.                 'command' => $command,
  191.                 'env' => $this->env,
  192.                 'timeout' => $this->timeout,
  193.             ]);
  194.         }
  196.         try {
  197.             list($status, $stdout, $stderr) = $this->executeCommand($command);
  198.             $this->checkProcessStatus($status, $stdout, $stderr, $command);
  199.             $this->checkOutput($output, $command);
  200.         } catch (Exception $e) {
  201.             if (null !== $this->logger) {
  202.                 $this->logger->error(\sprintf('An error happened while generating "%s".', $output), [
  203.                     'command' => $command,
  204.                     'status' => $status ?? null,
  205.                     'stdout' => $stdout ?? null,
  206.                     'stderr' => $stderr ?? null,
  207.                 ]);
  208.             }
  210.             throw $e;
  211.         }
  213.         if (null !== $this->logger) {
  214.             $this->logger->info(\sprintf('File "%s" has been successfully generated.', $output), [
  215.                 'command' => $command,
  216.                 'stdout' => $stdout,
  217.                 'stderr' => $stderr,
  218.             ]);
  219.         }
  220.     }
  222.     /**
  223.      * {@inheritdoc}
  224.      */
  225.     public function generateFromHtml($html, $output, array $options = [], $overwrite = false)
  226.     {
  227.         $fileNames = [];
  228.         if (\is_array($html)) {
  229.             foreach ($html as $htmlInput) {
  230.                 $fileNames[] = $this->createTemporaryFile($htmlInput, 'html');
  231.             }
  232.         } else {
  233.             $fileNames[] = $this->createTemporaryFile($html, 'html');
  234.         }
  236.         $this->generate($fileNames, $output, $options, $overwrite);
  237.     }
  239.     /**
  240.      * {@inheritdoc}
  241.      */
  242.     public function getOutput($input, array $options = [])
  243.     {
  244.         $filename = $this->createTemporaryFile(null, $this->getDefaultExtension());
  246.         $this->generate($input, $filename, $options);
  248.         return $this->getFileContents($filename);
  249.     }
  251.     /**
  252.      * {@inheritdoc}
  253.      */
  254.     public function getOutputFromHtml($html, array $options = [])
  255.     {
  256.         $fileNames = [];
  257.         if (\is_array($html)) {
  258.             foreach ($html as $htmlInput) {
  259.                 $fileNames[] = $this->createTemporaryFile($htmlInput, 'html');
  260.             }
  261.         } else {
  262.             $fileNames[] = $this->createTemporaryFile($html, 'html');
  263.         }
  265.         return $this->getOutput($fileNames, $options);
  266.     }
  268.     /**
  269.      * Defines the binary.
  270.      *
  271.      * @param null|string $binary The path/name of the binary
  272.      *
  273.      * @return $this
  274.      */
  275.     public function setBinary($binary)
  276.     {
  277.         $this->binary = $binary;
  279.         return $this;
  280.     }
  282.     /**
  283.      * Returns the binary.
  284.      *
  285.      * @return null|string
  286.      */
  287.     public function getBinary()
  288.     {
  289.         return $this->binary;
  290.     }
  292.     /**
  293.      * Returns the command for the given input and output files.
  294.      *
  295.      * @param array|string $input   The input file
  296.      * @param string       $output  The ouput file
  297.      * @param array        $options An optional array of options that will be used
  298.      *                              only for this command
  299.      *
  300.      * @return string
  301.      */
  302.     public function getCommand($input, $output, array $options = [])
  303.     {
  304.         if (null === $this->binary) {
  305.             throw new LogicException('You must define a binary prior to conversion.');
  306.         }
  308.         $options = $this->mergeOptions($options);
  310.         return $this->buildCommand($this->binary, $input, $output, $options);
  311.     }
  313.     /**
  314.      * Removes all temporary files.
  315.      *
  316.      * @return void
  317.      */
  318.     public function removeTemporaryFiles()
  319.     {
  320.         foreach ($this->temporaryFiles as $file) {
  321.             $this->unlink($file);
  322.         }
  323.     }
  325.     /**
  326.      * Get TemporaryFolder.
  327.      *
  328.      * @return string
  329.      */
  330.     public function getTemporaryFolder()
  331.     {
  332.         if ($this->temporaryFolder === null) {
  333.             return \sys_get_temp_dir();
  334.         }
  336.         return $this->temporaryFolder;
  337.     }
  339.     /**
  340.      * Set temporaryFolder.
  341.      *
  342.      * @param string $temporaryFolder
  343.      *
  344.      * @return $this
  345.      */
  346.     public function setTemporaryFolder($temporaryFolder)
  347.     {
  348.         $this->temporaryFolder = $temporaryFolder;
  350.         return $this;
  351.     }
  353.     /**
  354.      * Reset all options to their initial values.
  355.      *
  356.      * @return void
  357.      */
  358.     public function resetOptions()
  359.     {
  360.         $this->options = [];
  361.         $this->configure();
  362.     }
  364.     /**
  365.      * This method must configure the media options.
  366.      *
  367.      * @return void
  368.      *
  369.      * @see AbstractGenerator::addOption()
  370.      */
  371.     abstract protected function configure();
  373.     /**
  374.      * Adds an option.
  375.      *
  376.      * @param string $name    The name
  377.      * @param mixed  $default An optional default value
  378.      *
  379.      * @throws InvalidArgumentException
  380.      *
  381.      * @return $this
  382.      */
  383.     protected function addOption($name, $default = null)
  384.     {
  385.         if (\array_key_exists($name, $this->options)) {
  386.             throw new InvalidArgumentException(\sprintf('The option \'%s\' already exists.', $name));
  387.         }
  389.         $this->options[$name] = $default;
  391.         return $this;
  392.     }
  394.     /**
  395.      * Adds an array of options.
  396.      *
  397.      * @param array $options
  398.      *
  399.      * @return $this
  400.      */
  401.     protected function addOptions(array $options)
  402.     {
  403.         foreach ($options as $name => $default) {
  404.             $this->addOption($name, $default);
  405.         }
  407.         return $this;
  408.     }
  410.     /**
  411.      * Merges the given array of options to the instance options and returns
  412.      * the result options array. It does NOT change the instance options.
  413.      *
  414.      * @param array $options
  415.      *
  416.      * @throws InvalidArgumentException
  417.      *
  418.      * @return array
  419.      */
  420.     protected function mergeOptions(array $options)
  421.     {
  422.         $mergedOptions = $this->options;
  424.         foreach ($options as $name => $value) {
  425.             if (!\array_key_exists($name, $mergedOptions)) {
  426.                 throw new InvalidArgumentException(\sprintf('The option \'%s\' does not exist.', $name));
  427.             }
  429.             $mergedOptions[$name] = $value;
  430.         }
  432.         return $mergedOptions;
  433.     }
  435.     /**
  436.      * Checks the specified output.
  437.      *
  438.      * @param string $output  The output filename
  439.      * @param string $command The generation command
  440.      *
  441.      * @throws RuntimeException if the output file generation failed
  442.      *
  443.      * @return void
  444.      */
  445.     protected function checkOutput($output, $command)
  446.     {
  447.         // the output file must exist
  448.         if (!$this->fileExists($output)) {
  449.             throw new RuntimeException(\sprintf('The file \'%s\' was not created (command: %s).', $output, $command));
  450.         }
  452.         // the output file must not be empty
  453.         if (0 === $this->filesize($output)) {
  454.             throw new RuntimeException(\sprintf('The file \'%s\' was created but is empty (command: %s).', $output, $command));
  455.         }
  456.     }
  458.     /**
  459.      * Checks the process return status.
  460.      *
  461.      * @param int    $status  The exit status code
  462.      * @param string $stdout  The stdout content
  463.      * @param string $stderr  The stderr content
  464.      * @param string $command The run command
  465.      *
  466.      * @throws RuntimeException if the output file generation failed
  467.      *
  468.      * @return void
  469.      */
  470.     protected function checkProcessStatus($status, $stdout, $stderr, $command)
  471.     {
  472.         if (0 !== $status && '' !== $stderr) {
  473.             throw new RuntimeException(\sprintf('The exit status code \'%s\' says something went wrong:' . "\n" . 'stderr: "%s"' . "\n" . 'stdout: "%s"' . "\n" . 'command: %s.', $status, $stderr, $stdout, $command), $status);
  474.         }
  475.     }
  477.     /**
  478.      * Creates a temporary file.
  479.      * The file is not created if the $content argument is null.
  480.      *
  481.      * @param null|string $content   Optional content for the temporary file
  482.      * @param null|string $extension An optional extension for the filename
  483.      *
  484.      * @return string The filename
  485.      */
  486.     protected function createTemporaryFile($content = null, $extension = null)
  487.     {
  488.         $dir = \rtrim($this->getTemporaryFolder(), \DIRECTORY_SEPARATOR);
  490.         if (!\is_dir($dir)) {
  491.             if (false === @\mkdir($dir, 0777, true) && !\is_dir($dir)) {
  492.                 throw new RuntimeException(\sprintf("Unable to create directory: %s\n", $dir));
  493.             }
  494.         } elseif (!\is_writable($dir)) {
  495.             throw new RuntimeException(\sprintf("Unable to write in directory: %s\n", $dir));
  496.         }
  498.         $filename = $dir . \DIRECTORY_SEPARATOR . \uniqid('knp_snappy', true);
  500.         if (null !== $extension) {
  501.             $filename .= '.' . $extension;
  502.         }
  504.         if (null !== $content) {
  505.             \file_put_contents($filename, $content);
  506.         }
  508.         $this->temporaryFiles[] = $filename;
  510.         return $filename;
  511.     }
  513.     /**
  514.      * Builds the command string.
  515.      *
  516.      * @param string       $binary  The binary path/name
  517.      * @param array|string $input   Url(s) or file location(s) of the page(s) to process
  518.      * @param string       $output  File location to the image-to-be
  519.      * @param array        $options An array of options
  520.      *
  521.      * @return string
  522.      */
  523.     protected function buildCommand($binary, $input, $output, array $options = [])
  524.     {
  525.         $command = $binary;
  526.         $escapedBinary = \escapeshellarg($binary);
  527.         if (\is_executable($escapedBinary)) {
  528.             $command = $escapedBinary;
  529.         }
  531.         foreach ($options as $key => $option) {
  532.             if (null !== $option && false !== $option) {
  533.                 if (true === $option) {
  534.                     // Dont't put '--' if option is 'toc'.
  535.                     if ($key === 'toc') {
  536.                         $command .= ' ' . $key;
  537.                     } else {
  538.                         $command .= ' --' . $key;
  539.                     }
  540.                 } elseif (\is_array($option)) {
  541.                     if ($this->isAssociativeArray($option)) {
  542.                         foreach ($option as $k => $v) {
  543.                             $command .= ' --' . $key . ' ' . \escapeshellarg($k) . ' ' . \escapeshellarg($v);
  544.                         }
  545.                     } else {
  546.                         foreach ($option as $v) {
  547.                             $command .= ' --' . $key . ' ' . \escapeshellarg($v);
  548.                         }
  549.                     }
  550.                 } else {
  551.                     // Dont't add '--' if option is "cover"  or "toc".
  552.                     if (\in_array($key, ['toc', 'cover'])) {
  553.                         $command .= ' ' . $key . ' ' . \escapeshellarg($option);
  554.                     } elseif (\in_array($key, ['image-dpi', 'image-quality'])) {
  555.                         $command .= ' --' . $key . ' ' . (int) $option;
  556.                     } else {
  557.                         $command .= ' --' . $key . ' ' . \escapeshellarg($option);
  558.                     }
  559.                 }
  560.             }
  561.         }
  563.         if (\is_array($input)) {
  564.             foreach ($input as $i) {
  565.                 $command .= ' ' . \escapeshellarg($i) . ' ';
  566.             }
  567.             $command .= \escapeshellarg($output);
  568.         } else {
  569.             $command .= ' ' . \escapeshellarg($input) . ' ' . \escapeshellarg($output);
  570.         }
  572.         return $command;
  573.     }
  575.     /**
  576.      * Return true if the array is an associative array
  577.      * and not an indexed array.
  578.      *
  579.      * @param array $array
  580.      *
  581.      * @return bool
  582.      */
  583.     protected function isAssociativeArray(array $array)
  584.     {
  585.         return (bool) \count(\array_filter(\array_keys($array), 'is_string'));
  586.     }
  588.     /**
  589.      * Executes the given command via shell and returns the complete output as
  590.      * a string.
  591.      *
  592.      * @param string $command
  593.      *
  594.      * @return array [status, stdout, stderr]
  595.      */
  596.     protected function executeCommand($command)
  597.     {
  598.         if (\method_exists(Process::class, 'fromShellCommandline')) {
  599.             $process = Process::fromShellCommandline($command, null, $this->env);
  600.         } else {
  601.             $process = new Process($command, null, $this->env);
  602.         }
  604.         if (null !== $this->timeout) {
  605.             $process->setTimeout($this->timeout);
  606.         }
  608.         $process->run();
  610.         return [
  611.             $process->getExitCode(),
  612.             $process->getOutput(),
  613.             $process->getErrorOutput(),
  614.         ];
  615.     }
  617.     /**
  618.      * Prepares the specified output.
  619.      *
  620.      * @param string $filename  The output filename
  621.      * @param bool   $overwrite Whether to overwrite the file if it already
  622.      *                          exist
  623.      *
  624.      * @throws FileAlreadyExistsException
  625.      * @throws RuntimeException
  626.      * @throws InvalidArgumentException
  627.      *
  628.      * @return void
  629.      */
  630.     protected function prepareOutput($filename, $overwrite)
  631.     {
  632.         if (!$this->isProtocolAllowed($filename)) {
  633.             throw new InvalidArgumentException(\sprintf('The output file scheme is not supported. Expected one of [\'%s\'].', \implode('\', \'', self::ALLOWED_PROTOCOLS)));
  634.         }
  636.         $directory = \dirname($filename);
  638.         if ($this->fileExists($filename)) {
  639.             if (!$this->isFile($filename)) {
  640.                 throw new InvalidArgumentException(\sprintf('The output file \'%s\' already exists and it is a %s.', $filename, $this->isDir($filename) ? 'directory' : 'link'));
  641.             }
  642.             if (false === $overwrite) {
  643.                 throw new FileAlreadyExistsException(\sprintf('The output file \'%s\' already exists.', $filename));
  644.             }
  645.             if (!$this->unlink($filename)) {
  646.                 throw new RuntimeException(\sprintf('Could not delete already existing output file \'%s\'.', $filename));
  647.             }
  648.         } elseif (!$this->isDir($directory) && !$this->mkdir($directory)) {
  649.             throw new RuntimeException(\sprintf('The output file\'s directory \'%s\' could not be created.', $directory));
  650.         }
  651.     }
  653.     /**
  654.      * Verifies if the given filename has a supported protocol.
  655.      *
  656.      * @param string $filename
  657.      *
  658.      * @throws InvalidArgumentException
  659.      *
  660.      * @return bool
  661.      */
  662.     protected function isProtocolAllowed($filename)
  663.     {
  664.         if (false === $parsedFilename = \parse_url($filename)) {
  665.             throw new InvalidArgumentException('The filename is not valid.');
  666.         }
  668.         $protocol = isset($parsedFilename['scheme']) ? \mb_strtolower($parsedFilename['scheme']) : 'file';
  670.         if (
  671.             \PHP_OS_FAMILY === 'Windows'
  672.             && \strlen($protocol) === 1
  673.             && \preg_match(self::WINDOWS_LOCAL_FILENAME_REGEX, $filename)
  674.         ) {
  675.             $protocol = 'file';
  676.         }
  678.         return \in_array($protocol, self::ALLOWED_PROTOCOLS, true);
  679.     }
  681.     /**
  682.      * Wrapper for the "file_get_contents" function.
  683.      *
  684.      * @param string $filename
  685.      *
  686.      * @return string
  687.      */
  688.     protected function getFileContents($filename)
  689.     {
  690.         $fileContent = \file_get_contents($filename);
  692.         if (false === $fileContent) {
  693.             throw new RuntimeException(\sprintf('Could not read file \'%s\' content.', $filename));
  694.         }
  696.         return $fileContent;
  697.     }
  699.     /**
  700.      * Wrapper for the "file_exists" function.
  701.      *
  702.      * @param string $filename
  703.      *
  704.      * @return bool
  705.      */
  706.     protected function fileExists($filename)
  707.     {
  708.         return \file_exists($filename);
  709.     }
  711.     /**
  712.      * Wrapper for the "is_file" method.
  713.      *
  714.      * @param string $filename
  715.      *
  716.      * @return bool
  717.      */
  718.     protected function isFile($filename)
  719.     {
  720.         return \strlen($filename) <= \PHP_MAXPATHLEN && \is_file($filename);
  721.     }
  723.     /**
  724.      * Wrapper for the "filesize" function.
  725.      *
  726.      * @param string $filename
  727.      *
  728.      * @return int
  729.      */
  730.     protected function filesize($filename)
  731.     {
  732.         $filesize = \filesize($filename);
  734.         if (false === $filesize) {
  735.             throw new RuntimeException(\sprintf('Could not read file \'%s\' size.', $filename));
  736.         }
  738.         return $filesize;
  739.     }
  741.     /**
  742.      * Wrapper for the "unlink" function.
  743.      *
  744.      * @param string $filename
  745.      *
  746.      * @return bool
  747.      */
  748.     protected function unlink($filename)
  749.     {
  750.         return $this->fileExists($filename) ? \unlink($filename) : false;
  751.     }
  753.     /**
  754.      * Wrapper for the "is_dir" function.
  755.      *
  756.      * @param string $filename
  757.      *
  758.      * @return bool
  759.      */
  760.     protected function isDir($filename)
  761.     {
  762.         return \is_dir($filename);
  763.     }
  765.     /**
  766.      * Wrapper for the mkdir function.
  767.      *
  768.      * @param string $pathname
  769.      *
  770.      * @return bool
  771.      */
  772.     protected function mkdir($pathname)
  773.     {
  774.         return \mkdir($pathname, 0777, true);
  775.     }
  776. }