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. }