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);
}
}
public function delete($spiBinaryFileId)
{
try {
$this->filesystem->delete($spiBinaryFileId);
} catch (FlysystemNotFoundException $e) {
throw new BinaryFileNotFoundException($spiBinaryFileId, $e);
}
}
/**
* 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 delete($path)
{
try {
return $this->filesystem->delete($path);
} catch (FileNotFoundException $exception) {
return false;
}
}
protected function copyFile($fromFullPath, $toFullPath, $replace = false)
{
$this->createDirectory(dirname($toFullPath));
if ($replace) {
$this->filesystem->delete($toFullPath);
}
if (!$this->filesystem->copy($fromFullPath, $toFullPath)) {
throw new CommandErrorException('File cannot be copied to the path ' . $toFullPath);
}
}
public function handle(DeleteAvatarCommand $command)
{
$user = $this->users->findOrFail($command->userId);
// Make sure the current user is allowed to edit the user profile.
// This will let admins and the user themselves pass through, and
// throw an exception otherwise.
$user->assertCan($command->actor, 'edit');
$avatarPath = $user->avatar_path;
$user->changeAvatarPath(null);
event(new AvatarWillBeDeleted($user, $command));
$this->uploadDir->delete($avatarPath);
$user->save();
$this->dispatchEventsFor($user);
return $user;
}
/**
* Cleanup old sessions
* @link http://php.net/manual/en/sessionhandlerinterface.gc.php
* @param int $maxlifetime <p>
* Sessions that have not updated for
* the last maxlifetime seconds will be removed.
* </p>
* @return bool <p>
* The return value (usually TRUE on success, FALSE on failure).
* Note this value is returned internally to PHP for processing.
* </p>
* @since 5.4.0
*/
public function gc($maxlifetime)
{
$files = Finder::create()->in($this->path)->files()->ignoreDotFiles(true)->date('<= now - ' . $maxlifetime . ' seconds');
foreach ($files as $file) {
$this->driver->delete($file->getRealPath());
}
}
function it_can_remove_old_backups(FilesystemInterface $filesystem)
{
$files = [['path' => '.gitignore'], ['path' => 'foo.sql'], ['path' => 'foo1.sql'], ['path' => 'foo2.sql'], ['path' => 'foo3.sql'], ['path' => 'foo4.sql'], ['path' => 'foo5.sql'], ['path' => 'foo6.sql']];
$filesystem->listFiles()->willReturn($files);
$filesystem->getTimestamp('foo.sql')->willReturn(10000);
$filesystem->getTimestamp('foo1.sql')->willReturn(500);
$filesystem->getTimestamp('foo2.sql')->willReturn(10000);
$filesystem->getTimestamp('foo3.sql')->willReturn(10000);
$filesystem->getTimestamp('foo4.sql')->willReturn(100);
$filesystem->getTimestamp('.gitignore')->willReturn(50);
$filesystem->getTimestamp('foo5.sql')->willReturn(10000);
$filesystem->getTimestamp('foo6.sql')->willReturn(10000);
$filesystem->delete('foo1.sql')->shouldBeCalled();
$filesystem->delete('foo4.sql')->shouldBeCalled();
$this->removeOldBackups(5)->shouldReturn(['foo4.sql', 'foo1.sql']);
}
/**
* {@inheritdoc}
*/
public function push(BackupInterface $backup)
{
$backupDirectory = $backup->getName();
if (!$this->flysystem->has($backupDirectory) && !$this->flysystem->createDir($backupDirectory)) {
throw new DestinationException(sprintf('Unable to create backup directory "%s" in flysystem destination.', $backupDirectory));
}
$removedBackupFiles = $this->getFiles($backupDirectory);
/**
* @var FileInterface $backupFile
*/
foreach ($backup->getFiles() as $backupFile) {
if (isset($removedBackupFiles[$backupFile->getRelativePath()])) {
unset($removedBackupFiles[$backupFile->getRelativePath()]);
}
$path = $backupDirectory . '/' . $backupFile->getRelativePath();
try {
if ($this->flysystem->has($path)) {
if ($backupFile->getModifiedAt() > new \DateTime('@' . $this->flysystem->getTimestamp($path))) {
$resource = fopen($backupFile->getPath(), 'r');
$this->flysystem->updateStream($path, $resource);
fclose($resource);
}
} else {
$resource = fopen($backupFile->getPath(), 'r');
$this->flysystem->putStream($path, $resource);
fclose($resource);
}
} catch (\Exception $e) {
throw new DestinationException(sprintf('Unable to backup file "%s" to flysystem destination.', $backupFile->getPath()), 0, $e);
}
}
/**
* @var FileInterface $removedBackupFile
*/
foreach ($removedBackupFiles as $removedBackupFile) {
$path = $backupDirectory . '/' . $removedBackupFile->getRelativePath();
try {
$this->flysystem->delete($path);
} catch (\Exception $e) {
throw new DestinationException(sprintf('Unable to cleanup backup destination "%s" after backup process, file "%s" could not be removed.', $backupDirectory, $path), 0, $e);
}
}
$this->removeEmptyDirectories($backupDirectory);
if (is_array($this->backups)) {
$this->backups[$backup->getName()] = $backup;
}
}
/**
* Delete the file at a given path.
*
* @param string|array $paths
* @return bool
*/
public function delete($paths)
{
$paths = is_array($paths) ? $paths : func_get_args();
foreach ($paths as $path) {
$this->driver->delete($path);
}
return true;
}
/**
* @param DeleteAvatar $command
* @return \Flarum\Core\User
* @throws PermissionDeniedException
*/
public function handle(DeleteAvatar $command)
{
$actor = $command->actor;
$user = $this->users->findOrFail($command->userId);
if ($actor->id !== $user->id) {
$this->assertCan($actor, 'edit', $user);
}
$avatarPath = $user->avatar_path;
$user->changeAvatarPath(null);
$this->events->fire(new AvatarWillBeDeleted($user, $actor));
$user->save();
if ($this->uploadDir->has($avatarPath)) {
$this->uploadDir->delete($avatarPath);
}
$this->dispatchEventsFor($user, $actor);
return $user;
}
public function it_can_will_error_and_roll_back_when_delete_fails(File $file)
{
$uuid = Uuid::uuid4();
$file->getUuid()->willReturn($uuid);
$this->pdo->beginTransaction()->shouldBeCalled();
$this->fileSystem->delete($uuid->toString())->willReturn(false);
$this->objectRepository->delete(File::TYPE, $uuid)->shouldNotBeCalled();
$this->pdo->rollBack()->shouldBeCalled();
$this->shouldThrow(\RuntimeException::class)->duringDelete($file);
}
private function createAndBackup($path, $content)
{
if ($this->enableBackup) {
if ($this->backup->has($path)) {
$this->backup->delete($path);
}
$this->backup->write($path, $content);
}
$this->master->write($path, $content);
}
/**
* Delete the file at a given path.
*
* @param string|array $paths
* @return bool
*/
public function delete($paths)
{
$paths = is_array($paths) ? $paths : func_get_args();
foreach ($paths as $path) {
try {
$this->driver->delete($path);
} catch (FileNotFoundException $e) {
//
}
}
return true;
}
public function delete(File $file)
{
$this->pdo->beginTransaction();
try {
if (!$this->fileSystem->delete($file->getUuid()->toString())) {
throw new \RuntimeException('Failed to delete file');
}
$this->objectRepository->delete(File::TYPE, $file->getUuid());
$this->pdo->commit();
} catch (\Throwable $exception) {
$this->pdo->rollBack();
throw $exception;
}
}
/**
* Delete the file at a given path.
*
* @param string|array $paths
* @return bool
*/
public function delete($paths)
{
$paths = is_array($paths) ? $paths : func_get_args();
$success = true;
foreach ($paths as $path) {
try {
if (!$this->driver->delete($path)) {
$success = false;
}
} catch (FileNotFoundException $e) {
$success = false;
}
}
return $success;
}
protected function uploadFile(UploadedFileInterface $content, $mime, $filePath)
{
$uri = $content->getStream()->getMetadata('uri');
if (!$uri) {
throw new SaveResourceErrorException('Unknown error: can\'t get uploaded file uri');
}
$uploadedMime = $this->filesystem->getMimetype($uri);
if ($mime !== $uploadedMime) {
/**
* Try to remove unnecessary file because UploadFile object can be emulated
* @see \Staticus\Middlewares\ActionPostAbstract::download
*/
$this->filesystem->delete($uri);
throw new WrongRequestException('Bad request: incorrect mime-type of the uploaded file');
}
$content->moveTo($filePath);
}
/**
* Erase a directory.
*
* @param string $dirname
* @throws WriteException
*/
private function ensuredEraseDir($dirname)
{
try {
$listing = $this->fs->listContents($dirname, false);
foreach ($listing as $item) {
if ($item['type'] === 'dir') {
$this->fs->deleteDir($item['path']);
} else {
$this->fs->delete($item['path']);
}
}
return;
} catch (Error $ex) {
} catch (Exception $ex) {
}
throw new WriteException("Directory {$dirname} could not be erased.", $ex);
}
/**
* Erase a directory.
*
* @param string $dirname
* @throws IoWriteException
*/
public function eraseDir($dirname = '')
{
try {
$listing = $this->fs->listContents($dirname, false);
foreach ($listing as $item) {
if ($item['type'] === 'dir') {
$this->fs->deleteDir($item['path']);
} else {
$this->fs->delete($item['path']);
}
}
} catch (Error $ex) {
throw new IoWriteException("Directory {$dirname} could not be erased.", $ex);
} catch (Exception $ex) {
throw new IoWriteException("Directory {$dirname} could not be erased.", $ex);
}
}
/**
* Downloads the packages zipball from github and extracts it.
*
* @param array $package The selected version of the package.
* @return void
*/
private function downloadAndExtractPackageZipBall($package)
{
// NOTE: We actually use this list to determin if there are any stale
// packages that need to be deleted, so we generate the list here
// before we decide if we need to actually download the package or not.
if (!isset($this->downloaded[$package['name']])) {
$this->downloaded[$package['name']] = [];
}
if (!Linq::from($this->downloaded[$package['name']])->contains($package['version_normalized'])) {
$this->downloaded[$package['name']][] = $package['version_normalized'];
}
$packagePath = $this->vendorDir . '/' . $package['name'] . '/' . $package['version_normalized'];
if ($this->filesystem->has($packagePath)) {
$this->notify("ALREADY HAVE PACKAGE\n");
return;
}
$url = $package['dist']['url'];
$zipBall = $this->http->request('GET', $url)->getBody();
$zipBallPath = $packagePath . '/dist.zip';
$this->filesystem->put($zipBallPath, $zipBall);
$this->zip->extract($zipBallPath, $packagePath);
$this->filesystem->delete($zipBallPath);
$this->notify("DONE\n");
}
/**
* @param resource $stream
*/
public function write($stream)
{
$this->_filesystem->delete($this->getPath());
$this->_filesystem->writeStream($this->getPath(), $stream);
}
/**
* Remove file
*
* @param string $path file path
* @return bool
**/
protected function _unlink($path)
{
return $this->fs->delete($path);
}
/**
* @param string $containerName
* @param string $fileName
* @param string|null $relativePath
*
* @return bool
*/
public function deleteFile($containerName, $fileName, $relativePath)
{
$fullFileName = $this->getFullFileName($containerName, $fileName, $relativePath);
return $this->filesystem->delete($fullFileName);
}
/**
* Deletes a path from a filesystem
*
* @param \League\Flysystem\FilesystemInterface $filesystem a filesystem writer
* @param string $path the path that should be deleted
* @return bool
*/
public function deletePath(FilesystemInterface $filesystem, $path)
{
$success = false;
try {
$success = $filesystem->delete($path);
} catch (FileNotFoundException $e) {
// TODO: log this?
}
return $success;
}
/**
* Removes a file from the filesystem. This does not check if the file is
* still used or if it is a bad idea to delete it for some other reason
* this has to be taken care of in the upper layers (e.g. the Storage)!
*
* @param string $fileIdentifier
* @return bool TRUE if deleting the file succeeded
*/
public function deleteFile($fileIdentifier)
{
return $this->filesystem->delete($fileIdentifier);
}
/**
* Delete a file.
*
* @param string $path
*
* @throws FileNotFoundException
*
* @return bool True on success, false on failure.
*/
public function delete($path)
{
return $this->fileSystem->delete($path);
}
/**
* @inheritdoc
*/
public function delete($path)
{
$path = $this->strategy->encode($path);
return $this->filesystem->delete($path);
}
/**
* @param \Illuminate\Support\Collection $files
*/
private function deleteFiles($files)
{
foreach ($files as $file) {
$this->filesystem->delete($file['path']);
}
}
/**
* Move a file to a new location.
*
* @param string $from
* @param string $to
* @return bool
*/
public function move($from, $to)
{
$this->driver->copy($from, $to);
$this->driver->delete($from);
}
/**
* @param $filePath
*/
protected function deleteFile($filePath)
{
if (!$this->filesystem->delete($filePath)) {
throw new CommandErrorException('The file cannot be removed: ' . $filePath);
}
}
