function it_throws_an_exception_when_the_file_can_not_be_read_on_the_filesystem(FileInterface $file, FilesystemInterface $filesystem)
{
$file->getKey()->willReturn('path/to/file.txt');
$filesystem->has('path/to/file.txt')->willReturn(true);
$filesystem->readStream('path/to/file.txt')->willReturn(false);
$this->shouldThrow(new FileTransferException('Unable to fetch the file "path/to/file.txt" from the filesystem.'))->during('fetch', [$file, $filesystem]);
}
protected function deleteFile($filePath)
{
// If file is already gone somewhere, it is OK for us
if ($this->filesystem->has($filePath) && !$this->filesystem->delete($filePath)) {
throw new CommandErrorException('The file cannot be removed: ' . $filePath);
}
}
/**
* Return string error message if not found to be correct
*
* @return string|bool
*/
public function assertBackups($today)
{
$day = $today;
$sizes = [];
for ($i = 0; $i < 2; $i++) {
$expected = 's77_mail_' . $day->format('Y-m-d') . '.tar.gz';
try {
$size = $this->filesystem->getSize($expected);
if ($size === false) {
return "Kan bestandsgrootte niet ophalen van '{$expected}'";
}
$sizes[] = $size;
if ($size < 3.4 * 1000 * 1000 * 1000) {
$humanSize = $size / 1000 / 1000;
return "Email backup lijkt te klein ({$humanSize} MB)";
}
} catch (\League\Flysystem\FileNotFoundException $e) {
return "Kon email backup niet vinden: '{$expected}'";
}
$day = $day->sub(new \DateInterval('P1D'));
}
if (count(array_unique($sizes)) === 1) {
return "Laatste twee e-mail backups zijn even groot.";
}
return true;
}
private function touchDir(FilesystemInterface $fs, string $entityId, string $collectionUID, string $imageId) : string
{
$resultPath = sprintf('%s/%s/%s', $entityId, $collectionUID, $imageId);
if (!$fs->has($resultPath)) {
$fs->createDir($resultPath);
}
return $resultPath;
}
/**
* {@inheritdoc}
*/
public function toFile(Workout $workout, string $outputFile) : bool
{
$return = $this->filesystem->put($outputFile, $this->toString($workout));
if ($return !== true) {
throw new Exception(sprintf('Could not write to %s', $outputFile));
}
return true;
}
public function testLastBackupsIdentical()
{
$meta = $this->getMeta(123123123123.0);
$this->fs->getSize('s77_mail_2015-04-22.tar.gz')->willReturn($meta);
$this->fs->getSize('s77_mail_2015-04-21.tar.gz')->willReturn($meta);
$result = $this->assert->assertBackups(new \DateTime('2015-04-22'));
$this->assertEquals("Laatste twee e-mail backups zijn even groot.", $result);
}
public function getResource($spiBinaryFileId)
{
try {
return $this->filesystem->readStream($spiBinaryFileId);
} catch (FlysystemNotFoundException $e) {
throw new BinaryFileNotFoundException($spiBinaryFileId, $e);
}
}
/** @inheritdoc */
public function generate(array $replacements, $autoloader)
{
ReflectionEngine::init(new Locator($autoloader));
foreach ($replacements as $replacement) {
$fullPath = $this->vendorDir . '/' . $replacement['package'] . '/proxy/' . str_replace('\\', '/', $replacement['originalFullyQualifiedType']) . ".php";
$this->filesystem->put($fullPath, $this->buildClass($replacement));
}
}
/**
* {@inheritdoc}
*/
public function delete($path)
{
try {
return $this->filesystem->delete($path);
} catch (FileNotFoundException $exception) {
return false;
}
}
/**
* Delete an item from the storage if it exists.
*
* @param string $key
*
* @return void
*/
public function delete($key)
{
try {
$this->flysystem->delete($key);
} catch (FileNotFoundException $e) {
//
}
}
/**
* {@inheritdoc}
*/
public function find($path)
{
if ($this->filesystem->has($path) === false) {
throw new NotLoadableException(sprintf('Source image "%s" not found.', $path));
}
$mimeType = $this->filesystem->getMimetype($path);
return new Binary($this->filesystem->read($path), $mimeType, $this->extensionGuesser->guess($mimeType));
}
/**
* {@inheritdoc}
*/
public function fromFile($file) : Workout
{
$content = $this->filesystem->read($file);
if ($content === false) {
throw new UnreadableFileException();
}
return $this->fromString($content);
}
protected function adapterType()
{
if ($this->filesystem instanceof Filesystem) {
$reflect = new \ReflectionClass($this->filesystem->getAdapter());
return $reflect->getShortName();
}
return 'Unknown';
}
/**
* Create response.
* @param FilesystemInterface $cache Cache file system.
* @param string $path Cached file path.
* @return Response Response object.
*/
public function create(FilesystemInterface $cache, $path)
{
$stream = $this->streamCallback->__invoke($cache->readStream($path));
$contentType = $cache->getMimetype($path);
$contentLength = (string) $cache->getSize($path);
$cacheControl = 'max-age=31536000, public';
$expires = date_create('+1 years')->format('D, d M Y H:i:s') . ' GMT';
return $this->response->withBody($stream)->withHeader('Content-Type', $contentType)->withHeader('Content-Length', $contentLength)->withHeader('Cache-Control', $cacheControl)->withHeader('Expires', $expires);
}
/**
* Returns a list of Identifier strings
* Unfortunately the list() method is reserved
*
* @return string[]
*/
public function getList()
{
$identifiers = array();
$fileList = $this->filesystem->listFiles($this->getPath());
foreach ($fileList as $file) {
$identifiers[] = $file['filename'];
}
return $identifiers;
}
/**
* @return array
*/
private function getConnectorsFromFileList()
{
$connectors = [];
$connectorClasses = $this->locator->locate();
foreach ($connectorClasses as $connectorClass) {
// @FIXME: Use Dependency Injection Container for connectors that have dependencies
$connectors[] = new $connectorClass();
}
return $connectors;
}
/**
* @throws FileNotFoundException If fname does not exist in filesystem
*/
public function __construct(string $fname, FilesystemInterface $fsystem, DecoderInterface $decoder = null)
{
if (!$fsystem->has($fname)) {
throw new FileNotFoundException("Unable to read file {$fname}");
}
$this->fname = $fname;
$this->fsystem = $fsystem;
$this->decoder = $decoder ?: $this->guessDecoder();
$this->reset();
}
public function getFileHash($path)
{
$stream = $this->filesystem->readStream($path);
if ($stream !== false) {
$context = hash_init(self::HASH_ALGORITHM);
hash_update_stream($context, $stream);
return hash_final($context);
}
return false;
}
/**
* @param ReflectionClass $reflection
* @param FilesystemInterface $filesystem
* @param null $name
*/
public function __construct(ReflectionClass $reflection, FilesystemInterface $filesystem, $name = null)
{
$this->reflection = $reflection;
$this->template = $filesystem->read("/Console/stubs/method.stub");
$this->name = $name;
$this->classParameters = $this->getClassParameters();
$this->uses = $this->getUsages();
$this->methodParameterNames = $this->getMethodParameters();
$this->requestParameters = $this->getRequestParameters();
}
/**
* Set the stream response content.
* @param StreamedResponse $response The response object.
* @return StreamedResponse
*/
public function setContent(StreamedResponse $response)
{
$stream = $this->cache->readStream($this->path);
$response->setCallback(function () use($stream) {
rewind($stream);
fpassthru($stream);
fclose($stream);
});
return $response;
}
/**
* @param FilesystemInterface $filesystem
* @param string $fileName
*
* @throws StorageException
*/
public function __construct(FilesystemInterface $filesystem, $fileName = self::DEFAULT_FILENAME)
{
if (!$filesystem->has($fileName)) {
$filesystem->write($fileName, '');
}
$handler = $filesystem->get($fileName);
if (!$handler->isFile()) {
throw new StorageException(sprintf('Expected path "%s" to be a file but its a "%s".', $handler->getPath(), $handler->getType()));
}
$this->file = $handler;
}
protected function getPaths(FilesystemInterface $filesystem, $skipDirs)
{
$paths = [];
foreach ($filesystem->listContents($this->dir, true) as $path) {
if ($skipDirs && $path['type'] === 'dir') {
continue;
}
$paths[$path['path']] = $path;
}
ksort($paths);
return $paths;
}
public function handle($term, $extensions = 'jpg,jpeg,gif,png')
{
$extensions = explode(",", $extensions);
$allFiles = $this->filesystem->listContents('', true);
$files = array();
foreach ($allFiles as $file) {
if ($file['type'] == 'file' && ($term == '*' || strpos($file['path'], $term) !== false) && in_array($file['extension'], $extensions)) {
$files[] = $file['path'];
}
}
return $files;
}
/**
* Create response.
*
* @param \League\Flysystem\FilesystemInterface $cache Cache file system.
* @param string $path Cached file path.
*
* @return \Psr\Http\Message\ResponseInterface Response object.
*/
public function create(FilesystemInterface $cache, $path)
{
$stream = new Stream($cache->readStream($path));
$contentType = $cache->getMimetype($path);
$contentLength = (string) $cache->getSize($path);
if ($contentType === false) {
throw new FilesystemException('Unable to determine the image content type.');
}
if ($contentLength === false) {
throw new FilesystemException('Unable to determine the image content length.');
}
return (new Response())->withBody($stream)->withHeader('Content-Type', $contentType)->withHeader('Content-Length', $contentLength);
}
/**
* Should pre-process and transfer an image.
*/
public function testHandle()
{
$filename = '/tmp/' . uniqid();
file_put_contents($filename, '');
$this->image->expects($this->atLeastOnce())->method('storageLocation')->willReturn($filename);
$preProcessed = $this->makeMock(ImagickContract::class);
$this->imagePreProcessor->expects($this->atLeastOnce())->method('preProcess')->with($this->image)->willReturn(new ImagickCollection([$preProcessed]));
$this->config->expects($this->atLeastOnce())->method('get')->willReturn('foobar_endpoint');
$fileContent = 'foo bar';
$preProcessed->expects($this->atLeastOnce())->method('getImageBlob')->willReturn($fileContent);
$this->filesystem->expects($this->atLeastOnce())->method('put')->with($this->isType('string'), $fileContent, $this->isType('array'));
$this->newImageListener->handle($this->event);
}
/**
* @param ServerRequestInterface $request
*
* @return mixed|null
*/
public function data(ServerRequestInterface $request)
{
$url = $request->getUri()->getPath();
$parameters = array_merge($request->getQueryParams(), $request->getParsedBody());
$file = $this->file($url, $parameters);
if (!$this->filesystem->has($file)) {
$file = $this->defaultFile($url);
}
if (!$this->filesystem->has($file)) {
return null;
}
return $this->filesystem->read($file);
}
/**
* Recursively yield files that meet the specification
*
* @param SpecificationInterface $specification
* @param string $path
* @return Generator
*/
private function yieldFilesInPath(SpecificationInterface $specification, $path)
{
$listContents = $this->filesystem->listContents($path);
foreach ($listContents as $location) {
if ($specification->isSatisfiedBy($location)) {
(yield $location);
}
if ($location['type'] == 'dir') {
foreach ($this->yieldFilesInPath($specification, $location['path']) as $returnedLocation) {
(yield $returnedLocation);
}
}
}
}
public function uploadImagePreview(int $themeId, string $path) : string
{
$theme = $this->getThemeById($themeId);
$dir = $theme->getId();
$name = sprintf('%s.png', GenerateRandomString::gen(self::GENERATE_FILENAME_LENGTH));
$newPath = sprintf('%s/%s', $dir, $name);
if ($this->fileSystem->has($dir)) {
$this->fileSystem->deleteDir($dir);
}
$this->fileSystem->write($newPath, file_get_contents($path));
$theme->setPreview($newPath);
$this->themeRepository->saveTheme($theme);
return $theme->getPreview();
}
/**
* {@inheritdoc}
*/
public function fetch(FileInterface $file, FilesystemInterface $filesystem)
{
if (!$filesystem->has($file->getKey())) {
throw new \LogicException(sprintf('The file "%s" is not present on the filesystem.', $file->getKey()));
}
$localPathname = tempnam(sys_get_temp_dir(), 'raw_file_fetcher_');
if (false === ($stream = $filesystem->readStream($file->getKey()))) {
throw new FileTransferException(sprintf('Unable to fetch the file "%s" from the filesystem.', $file->getKey()));
}
if (false === file_put_contents($localPathname, $stream)) {
throw new FileTransferException(sprintf('Unable to fetch the file "%s" from the filesystem.', $file->getKey()));
}
return new \SplFileInfo($localPathname);
}
/**
* {@inheritDoc}
*/
public function load($path)
{
try {
$contents = $this->filesystem->read($path);
} catch (FileNotFoundException $e) {
throw new Exception\ImageNotFoundException(sprintf('Source image not found in "%s"', $path));
}
$mimeType = $this->filesystem->getMimeType($path);
if ($mimeType === false) {
// Mime Type could not be detected
return $contents;
}
return new Binary($contents, $mimeType);
}
