vendor\symfony\http-kernel\Profiler\FileProfilerStorage.php line 166

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <[email protected]>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpKernel\Profiler;
  14. /**
  15.  * Storage for profiler using files.
  16.  *
  17.  * @author Alexandre Salomé <[email protected]>
  18.  */
  19. class FileProfilerStorage implements ProfilerStorageInterface
  20. {
  21.     /**
  22.      * Folder where profiler data are stored.
  23.      *
  24.      * @var string
  25.      */
  26.     private $folder;
  28.     /**
  29.      * Constructs the file storage using a "dsn-like" path.
  30.      *
  31.      * Example : "file:/path/to/the/storage/folder"
  32.      *
  33.      * @throws \RuntimeException
  34.      */
  35.     public function __construct(string $dsn)
  36.     {
  37.         if (!str_starts_with($dsn, 'file:')) {
  38.             throw new \RuntimeException(sprintf('Please check your configuration. You are trying to use FileStorage with an invalid dsn "%s". The expected format is "file:/path/to/the/storage/folder".', $dsn));
  39.         }
  40.         $this->folder = substr($dsn, 5);
  42.         if (!is_dir($this->folder) && false === @mkdir($this->folder, 0777, true) && !is_dir($this->folder)) {
  43.             throw new \RuntimeException(sprintf('Unable to create the storage directory (%s).', $this->folder));
  44.         }
  45.     }
  47.     /**
  48.      * {@inheritdoc}
  49.      */
  50.     public function find(?string $ip, ?string $url, ?int $limit, ?string $method, int $start = null, int $end = null, string $statusCode = null): array
  51.     {
  52.         $file = $this->getIndexFilename();
  54.         if (!file_exists($file)) {
  55.             return [];
  56.         }
  58.         $file = fopen($file, 'r');
  59.         fseek($file, 0, \SEEK_END);
  61.         $result = [];
  62.         while (\count($result) < $limit && $line = $this->readLineFromFile($file)) {
  63.             $values = str_getcsv($line);
  64.             [$csvToken, $csvIp, $csvMethod, $csvUrl, $csvTime, $csvParent, $csvStatusCode] = $values;
  65.             $csvTime = (int) $csvTime;
  67.             if ($ip && !str_contains($csvIp, $ip) || $url && !str_contains($csvUrl, $url) || $method && !str_contains($csvMethod, $method) || $statusCode && !str_contains($csvStatusCode, $statusCode)) {
  68.                 continue;
  69.             }
  71.             if (!empty($start) && $csvTime < $start) {
  72.                 continue;
  73.             }
  75.             if (!empty($end) && $csvTime > $end) {
  76.                 continue;
  77.             }
  79.             $result[$csvToken] = [
  80.                 'token' => $csvToken,
  81.                 'ip' => $csvIp,
  82.                 'method' => $csvMethod,
  83.                 'url' => $csvUrl,
  84.                 'time' => $csvTime,
  85.                 'parent' => $csvParent,
  86.                 'status_code' => $csvStatusCode,
  87.             ];
  88.         }
  90.         fclose($file);
  92.         return array_values($result);
  93.     }
  95.     /**
  96.      * {@inheritdoc}
  97.      */
  98.     public function purge()
  99.     {
  100.         $flags = \FilesystemIterator::SKIP_DOTS;
  101.         $iterator = new \RecursiveDirectoryIterator($this->folder, $flags);
  102.         $iterator = new \RecursiveIteratorIterator($iterator, \RecursiveIteratorIterator::CHILD_FIRST);
  104.         foreach ($iterator as $file) {
  105.             if (is_file($file)) {
  106.                 unlink($file);
  107.             } else {
  108.                 rmdir($file);
  109.             }
  110.         }
  111.     }
  113.     /**
  114.      * {@inheritdoc}
  115.      */
  116.     public function read(string $token): ?Profile
  117.     {
  118.         return $this->doRead($token);
  119.     }
  121.     /**
  122.      * {@inheritdoc}
  123.      *
  124.      * @throws \RuntimeException
  125.      */
  126.     public function write(Profile $profile): bool
  127.     {
  128.         $file = $this->getFilename($profile->getToken());
  130.         $profileIndexed = is_file($file);
  131.         if (!$profileIndexed) {
  132.             // Create directory
  133.             $dir = \dirname($file);
  134.             if (!is_dir($dir) && false === @mkdir($dir, 0777, true) && !is_dir($dir)) {
  135.                 throw new \RuntimeException(sprintf('Unable to create the storage directory (%s).', $dir));
  136.             }
  137.         }
  139.         $profileToken = $profile->getToken();
  140.         // when there are errors in sub-requests, the parent and/or children tokens
  141.         // may equal the profile token, resulting in infinite loops
  142.         $parentToken = $profile->getParentToken() !== $profileToken ? $profile->getParentToken() : null;
  143.         $childrenToken = array_filter(array_map(function (Profile $p) use ($profileToken) {
  144.             return $profileToken !== $p->getToken() ? $p->getToken() : null;
  145.         }, $profile->getChildren()));
  147.         // Store profile
  148.         $data = [
  149.             'token' => $profileToken,
  150.             'parent' => $parentToken,
  151.             'children' => $childrenToken,
  152.             'data' => $profile->getCollectors(),
  153.             'ip' => $profile->getIp(),
  154.             'method' => $profile->getMethod(),
  155.             'url' => $profile->getUrl(),
  156.             'time' => $profile->getTime(),
  157.             'status_code' => $profile->getStatusCode(),
  158.         ];
  160.         $data = serialize($data);
  162.         if (\function_exists('gzencode')) {
  163.             $data = gzencode($data, 3);
  164.         }
  166.         if (false === file_put_contents($file, $data, \LOCK_EX)) {
  167.             return false;
  168.         }
  170.         if (!$profileIndexed) {
  171.             // Add to index
  172.             if (false === $file = fopen($this->getIndexFilename(), 'a')) {
  173.                 return false;
  174.             }
  176.             fputcsv($file, [
  177.                 $profile->getToken(),
  178.                 $profile->getIp(),
  179.                 $profile->getMethod(),
  180.                 $profile->getUrl(),
  181.                 $profile->getTime(),
  182.                 $profile->getParentToken(),
  183.                 $profile->getStatusCode(),
  184.             ]);
  185.             fclose($file);
  186.         }
  188.         return true;
  189.     }
  191.     /**
  192.      * Gets filename to store data, associated to the token.
  193.      *
  194.      * @return string
  195.      */
  196.     protected function getFilename(string $token)
  197.     {
  198.         // Uses 4 last characters, because first are mostly the same.
  199.         $folderA = substr($token, -2, 2);
  200.         $folderB = substr($token, -4, 2);
  202.         return $this->folder.'/'.$folderA.'/'.$folderB.'/'.$token;
  203.     }
  205.     /**
  206.      * Gets the index filename.
  207.      *
  208.      * @return string
  209.      */
  210.     protected function getIndexFilename()
  211.     {
  212.         return $this->folder.'/index.csv';
  213.     }
  215.     /**
  216.      * Reads a line in the file, backward.
  217.      *
  218.      * This function automatically skips the empty lines and do not include the line return in result value.
  219.      *
  220.      * @param resource $file The file resource, with the pointer placed at the end of the line to read
  221.      *
  222.      * @return mixed
  223.      */
  224.     protected function readLineFromFile($file)
  225.     {
  226.         $line = '';
  227.         $position = ftell($file);
  229.         if (0 === $position) {
  230.             return null;
  231.         }
  233.         while (true) {
  234.             $chunkSize = min($position, 1024);
  235.             $position -= $chunkSize;
  236.             fseek($file, $position);
  238.             if (0 === $chunkSize) {
  239.                 // bof reached
  240.                 break;
  241.             }
  243.             $buffer = fread($file, $chunkSize);
  245.             if (false === ($upTo = strrpos($buffer, "\n"))) {
  246.                 $line = $buffer.$line;
  247.                 continue;
  248.             }
  250.             $position += $upTo;
  251.             $line = substr($buffer, $upTo + 1).$line;
  252.             fseek($file, max(0, $position), \SEEK_SET);
  254.             if ('' !== $line) {
  255.                 break;
  256.             }
  257.         }
  259.         return '' === $line ? null : $line;
  260.     }
  262.     protected function createProfileFromData(string $token, array $data, Profile $parent = null)
  263.     {
  264.         $profile = new Profile($token);
  265.         $profile->setIp($data['ip']);
  266.         $profile->setMethod($data['method']);
  267.         $profile->setUrl($data['url']);
  268.         $profile->setTime($data['time']);
  269.         $profile->setStatusCode($data['status_code']);
  270.         $profile->setCollectors($data['data']);
  272.         if (!$parent && $data['parent']) {
  273.             $parent = $this->read($data['parent']);
  274.         }
  276.         if ($parent) {
  277.             $profile->setParent($parent);
  278.         }
  280.         foreach ($data['children'] as $token) {
  281.             if (null !== $childProfile = $this->doRead($token, $profile)) {
  282.                 $profile->addChild($childProfile);
  283.             }
  284.         }
  286.         return $profile;
  287.     }
  289.     private function doRead($token, Profile $profile = null): ?Profile
  290.     {
  291.         if (!$token || !file_exists($file = $this->getFilename($token))) {
  292.             return null;
  293.         }
  295.         $h = fopen($file, 'r');
  296.         flock($h, \LOCK_SH);
  297.         $data = stream_get_contents($h);
  298.         flock($h, \LOCK_UN);
  299.         fclose($h);
  301.         if (\function_exists('gzdecode')) {
  302.             $data = @gzdecode($data) ?: $data;
  303.         }
  305.         if (!$data = unserialize($data)) {
  306.             return null;
  307.         }
  309.         return $this->createProfileFromData($token, $data, $profile);
  310.     }
  311. }