DiskFilestore.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Filesystem\Filestore;
 
use Elgg\Exceptions\DomainException;
use Elgg\Exceptions\Filesystem\IOException;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Filesystem\Filestore;
use Elgg\Project\Paths;
 
class DiskFilestore extends Filestore {
 
    protected $dir_root;
 
    const BUCKET_SIZE = 5000;
 
    public function __construct($directory_root = '') {
        if (!$directory_root) {
            $directory_root = _elgg_services()->config->dataroot;
        }
        
        $this->dir_root = Paths::sanitize($directory_root);
    }
 
    public function open(\ElggFile $file, string $mode) {
        $fullname = $this->getFilenameOnFilestore($file);
 
        // Split into path and name
        $ls = strrpos($fullname, '/');
        if ($ls === false) {
            $ls = 0;
        }
 
        $path = substr($fullname, 0, $ls);
 
        if (($mode === 'read') && (!file_exists($fullname))) {
            return false;
        }
 
        // Try to create the dir for valid write modes
        if ($mode == 'write' || $mode == 'append') {
            try {
                $this->makeDirectoryRoot($path);
            } catch (\Exception $e) {
                _elgg_services()->logger->warning($e);
                return false;
            }
        }
 
        switch ($mode) {
            case 'read':
                $mode = 'rb';
                break;
            case 'write':
                $mode = 'w+b';
                break;
            case 'append':
                $mode = 'a+b';
                break;
            default:
                throw new DomainException("Unrecognized file mode '{$mode}'");
        }
 
        return fopen($fullname, $mode);
    }
 
    public function write($f, $data): int {
        return fwrite($f, $data);
    }
 
    public function read($f, int $length, int $offset = 0): string|false {
        if ($offset) {
            $this->seek($f, $offset);
        }
 
        return fread($f, $length);
    }
 
    public function close($f): bool {
        return fclose($f);
    }
 
    public function delete(\ElggFile $file, bool $follow_symlinks = true): bool {
        $filename = $this->getFilenameOnFilestore($file);
        if (file_exists($filename) || is_link($filename)) {
            if ($follow_symlinks && is_link($filename) && file_exists($filename)) {
                $target = readlink($filename);
                file_exists($target) && unlink($target);
            }
            
            return unlink($filename);
        }
 
        return true;
    }
 
    public function seek($f, int $position): int {
        return fseek($f, $position);
    }
 
    public function tell($f): int|false {
        return ftell($f);
    }
 
    public function eof($f): bool {
        return feof($f);
    }
 
    public function getFileSize(\ElggFile $file): int {
        return filesize($this->getFilenameOnFilestore($file));
    }
 
    public function getFilenameOnFilestore(\ElggFile $file): string {
        
        $owner_guid = null;
        if (!empty($file->guid) && $file->getSubtype() === 'file') {
            $owner_guid = $file->guid;
        }
    
        if (empty($owner_guid)) {
            $owner_guid = $file->owner_guid ?: _elgg_services()->session_manager->getLoggedInUserGuid();
        }
 
        if (empty($owner_guid)) {
            throw new InvalidArgumentException("File {$file->getFilename()} (file guid: {$file->guid}) is missing an owner!");
        }
 
        $filename = $file->getFilename();
        if (!$filename) {
            return '';
        }
 
        $dir = new \Elgg\EntityDirLocator($owner_guid);
 
        return Paths::sanitize($this->dir_root . $dir . $file->getFilename(), false);
    }
 
    public function grabFile(\ElggFile $file): string|false {
        return file_get_contents($file->getFilenameOnFilestore());
    }
 
    public function exists(\ElggFile $file): bool {
        if (!$file->getFilename()) {
            return false;
        }
        
        try {
            $real_filename = $this->getFilenameOnFilestore($file);
        } catch (InvalidArgumentException $e) {
            // something wrong with the filename
            return false;
        }
 
        return file_exists($real_filename);
    }
 
    protected function makeDirectoryRoot($dirroot): void {
        if (file_exists($dirroot)) {
            return;
        }
        
        error_clear_last();
        if (!@mkdir($dirroot, 0755, true)) {
            $last_error = error_get_last();
            
            $message = elgg_extract('message', $last_error);
            if (!elgg_is_empty($message)) {
                $message = ": {$message}";
            }
            
            throw new IOException("Couldn't create directory: {$dirroot}{$message}");
        }
    }
 
    public function getParameters(): array {
        return [
            'dir_root' => $this->dir_root,
        ];
    }
 
    public function setParameters(array $parameters): bool {
        if (isset($parameters['dir_root'])) {
            $this->dir_root = Paths::sanitize($parameters['dir_root']);
            return true;
        }
 
        return false;
    }
}