6449927556

Committed 08 Oct 2023 08:55PM UTC coverage: 90.363% (+0.05%) from 90.309%

Build # 6449927556

Build Type

push

github

Committed by

xificurk

Commit Message

Drop useless dev dependency

Run Details

647 of 716 relevant lines covered (90.36%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.5

/src/FileUploadControl/Storage/FileSystemStorageManager.php

<?php
declare(strict_types = 1);

namespace Nepada\FileUploadControl\Storage;

use Nepada\FileUploadControl\Storage\Metadata\MetadataJournalProvider;
use Nepada\FileUploadControl\Utils\DateTimeProvider;
use Nepada\FileUploadControl\Utils\FileSystem;
use Nepada\FileUploadControl\Utils\Finder;
use Nepada\FileUploadControl\Utils\RandomProvider;
use Nette;

final class FileSystemStorageManager implements StorageManager
{

    use Nette\SmartObject;

    public const DEFAULT_TTL = Nette\Utils\DateTime::DAY;

    private const NAMESPACE_DIRECTORY_SUFFIX = '-files';

    private MetadataJournalProvider $metadataJournalProvider;

    private FileSystem $fileSystem;

    private Finder $finder;

    private DateTimeProvider $dateTimeProvider;

    private RandomProvider $randomProvider;

    private string $directory;

    private int $namespaceTtl;

    private bool $garbageCollected = false;

    public function __construct(
        MetadataJournalProvider $metadataJournalProvider,
        FileSystem $fileSystem,
        Finder $finder,
        DateTimeProvider $dateTimeProvider,
        RandomProvider $randomProvider,
        string $directory,
        int $namespaceTtl = self::DEFAULT_TTL,
    )
    {
        $this->metadataJournalProvider = $metadataJournalProvider;
        $this->fileSystem = $fileSystem;
        $this->finder = $finder;
        $this->dateTimeProvider = $dateTimeProvider;
        $this->randomProvider = $randomProvider;
        $this->directory = $directory;
        $this->namespaceTtl = $namespaceTtl;
    }

    public function createNewNamespace(): UploadNamespace
    {
        $this->collectGarbage();
        $namespace = UploadNamespace::generate($this->randomProvider);
        $directory = $this->getUploadNamespaceDirectory($namespace);
        $this->fileSystem->createDirectory($directory);
        return $namespace;
    }

    /**
     * @throws StorageDoesNotExistException
     */
    public function getStorage(UploadNamespace $namespace): Storage
    {
        $this->collectGarbage();
        $directory = $this->getUploadNamespaceDirectory($namespace);
        if (! $this->fileSystem->directoryExists($directory)) {
            throw StorageDoesNotExistException::withNamespace($namespace);
        }

        $metadataJournal = $this->metadataJournalProvider->get($namespace);
        return new FileSystemStorage($metadataJournal, $this->fileSystem, $directory);
    }

    private function collectGarbage(): void
    {
        if ($this->garbageCollected) {
            return;
        }

        $this->garbageCollected = true;

        if (! $this->fileSystem->directoryExists($this->directory)) {
            return;
        }

        $expiredNamespaces = [];
        $currentTimestamp = $this->dateTimeProvider->getNow()->getTimestamp();
        /** @var \SplFileInfo $directory */
        foreach ($this->finder->findDirectoriesInDirectory($this->directory, '*' . self::NAMESPACE_DIRECTORY_SUFFIX) as $directory) {
            $age = $currentTimestamp - $directory->getMTime();
            if ($age < $this->namespaceTtl) {
                continue;
            }
            $expiredNamespaces[] = UploadNamespace::fromString($directory->getBasename(self::NAMESPACE_DIRECTORY_SUFFIX));
        }

        foreach ($expiredNamespaces as $expiredNamespace) {
            try {
                $storage = $this->getStorage($expiredNamespace);
                $storage->destroy();
            } catch (StorageDoesNotExistException $exception) {
                // noop
            }
        }
    }

    private function getUploadNamespaceDirectory(UploadNamespace $namespace): string
    {
        return $this->directory . DIRECTORY_SEPARATOR . $namespace->toString() . self::NAMESPACE_DIRECTORY_SUFFIX;
    }

}

1	<?php
2	declare(strict_types = 1);
3
4	namespace Nepada\FileUploadControl\Storage;
5
6	use Nepada\FileUploadControl\Storage\Metadata\MetadataJournalProvider;
7	use Nepada\FileUploadControl\Utils\DateTimeProvider;
8	use Nepada\FileUploadControl\Utils\FileSystem;
9	use Nepada\FileUploadControl\Utils\Finder;
10	use Nepada\FileUploadControl\Utils\RandomProvider;
11	use Nette;
12
13	final class FileSystemStorageManager implements StorageManager
14	{
15
16	use Nette\SmartObject;
17
18	public const DEFAULT_TTL = Nette\Utils\DateTime::DAY;
19
20	private const NAMESPACE_DIRECTORY_SUFFIX = '-files';
21
22	private MetadataJournalProvider $metadataJournalProvider;
23
24	private FileSystem $fileSystem;
25
26	private Finder $finder;
27
28	private DateTimeProvider $dateTimeProvider;
29
30	private RandomProvider $randomProvider;
31
32	private string $directory;
33
34	private int $namespaceTtl;
35
36	private bool $garbageCollected = false;
37
38	public function __construct(	1✔
39	MetadataJournalProvider $metadataJournalProvider,
40	FileSystem $fileSystem,
41	Finder $finder,
42	DateTimeProvider $dateTimeProvider,
43	RandomProvider $randomProvider,
44	string $directory,
45	int $namespaceTtl = self::DEFAULT_TTL,
46	)
47	{
48	$this->metadataJournalProvider = $metadataJournalProvider;	1✔
49	$this->fileSystem = $fileSystem;	1✔
50	$this->finder = $finder;	1✔
51	$this->dateTimeProvider = $dateTimeProvider;	1✔
52	$this->randomProvider = $randomProvider;	1✔
53	$this->directory = $directory;	1✔
54	$this->namespaceTtl = $namespaceTtl;	1✔
55	}	1✔
56
57	public function createNewNamespace(): UploadNamespace
58	{
59	$this->collectGarbage();	1✔
60	$namespace = UploadNamespace::generate($this->randomProvider);	1✔
61	$directory = $this->getUploadNamespaceDirectory($namespace);	1✔
62	$this->fileSystem->createDirectory($directory);	1✔
63	return $namespace;	1✔
64	}
65
66	/**
67	* @throws StorageDoesNotExistException
68	*/
69	public function getStorage(UploadNamespace $namespace): Storage	1✔
70	{
71	$this->collectGarbage();	1✔
72	$directory = $this->getUploadNamespaceDirectory($namespace);	1✔
73	if (! $this->fileSystem->directoryExists($directory)) {	1✔
74	throw StorageDoesNotExistException::withNamespace($namespace);	1✔
75	}
76
77	$metadataJournal = $this->metadataJournalProvider->get($namespace);	1✔
78	return new FileSystemStorage($metadataJournal, $this->fileSystem, $directory);	1✔
79	}
80
81	private function collectGarbage(): void
82	{
83	if ($this->garbageCollected) {	1✔
84	return;	1✔
85	}
86
87	$this->garbageCollected = true;	1✔
88
89	if (! $this->fileSystem->directoryExists($this->directory)) {	1✔
90	return;	1✔
91	}
92
93	$expiredNamespaces = [];	1✔
94	$currentTimestamp = $this->dateTimeProvider->getNow()->getTimestamp();	1✔
95	/** @var \SplFileInfo $directory */
96	foreach ($this->finder->findDirectoriesInDirectory($this->directory, '*' . self::NAMESPACE_DIRECTORY_SUFFIX) as $directory) {	1✔
97	$age = $currentTimestamp - $directory->getMTime();	1✔
98	if ($age < $this->namespaceTtl) {	1✔
99	continue;	1✔
100	}
101	$expiredNamespaces[] = UploadNamespace::fromString($directory->getBasename(self::NAMESPACE_DIRECTORY_SUFFIX));	1✔
102	}
103
104	foreach ($expiredNamespaces as $expiredNamespace) {	1✔
105	try {
106	$storage = $this->getStorage($expiredNamespace);	1✔
107	$storage->destroy();	1✔
108	} catch (StorageDoesNotExistException $exception) {	×
109	// noop
110	}
111	}
112	}	1✔
113
114	private function getUploadNamespaceDirectory(UploadNamespace $namespace): string	1✔
115	{
116	return $this->directory . DIRECTORY_SEPARATOR . $namespace->toString() . self::NAMESPACE_DIRECTORY_SUFFIX;	1✔
117	}
118
119	}

nepada / file-upload-control / 6449927556

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous