ElggDiskFilestore.php

Go to the documentation of this file.

<?php

use Elgg\Exceptions\InvalidParameterException;
use Elgg\Exceptions\Filesystem\IOException;
use Elgg\Project\Paths;

class ElggDiskFilestore extends \ElggFilestore {

    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, $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("Couldn't create directory: {$path}");
                return false;
            }
        }

        switch ($mode) {
            case 'read' :
                $mode = 'rb';
                break;
            case 'write' :
                $mode = 'w+b';
                break;
            case 'append' :
                $mode = 'a+b';
                break;
            default:
                throw new InvalidParameterException("Unrecognized file mode '{$mode}'");
        }

        return fopen($fullname, $mode);
    }

    public function write($f, $data) {
        return fwrite($f, $data);
    }

    public function read($f, $length, $offset = 0) {
        if ($offset) {
            $this->seek($f, $offset);
        }

        return fread($f, $length);
    }

    public function close($f) {
        return fclose($f);
    }

    public function delete(\ElggFile $file, $follow_symlinks = true) {
        $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, $position) {
        return fseek($f, $position);
    }

    public function tell($f) {
        return ftell($f);
    }

    public function eof($f) {
        return feof($f);
    }

    public function getFileSize(\ElggFile $file) {
        return filesize($this->getFilenameOnFilestore($file));
    }

    public function getFilenameOnFilestore(\ElggFile $file) {
        $owner_guid = $file->getOwnerGuid();
        if (!$owner_guid) {
            $owner_guid = _elgg_services()->session->getLoggedInUserGuid();
        }

        if (!$owner_guid) {
            throw new InvalidParameterException("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) {
        return file_get_contents($file->getFilenameOnFilestore());
    }

    public function exists(\ElggFile $file) {
        if (!$file->getFilename()) {
            return false;
        }
        
        try {
            $real_filename = $this->getFilenameOnFilestore($file);
        } catch (InvalidParameterException $e) {
            // something wrong with the filename
            return false;
        }

        return file_exists($real_filename);
    }

    public function getSize($prefix, $container_guid) {
        if ($container_guid) {
            $dir = new \Elgg\EntityDirLocator($container_guid);
            
            return get_dir_size(Paths::sanitize($this->dir_root . $dir . $prefix));
        }
        
        return false;
    }

    protected function makeDirectoryRoot($dirroot) {
        if (!file_exists($dirroot)) {
            if (!@mkdir($dirroot, 0755, true)) {
                throw new IOException("Could not make {$dirroot}");
            }
        }

        return true;
    }

    public function getParameters() {
        return [
            'dir_root' => $this->dir_root,
        ];
    }

    public function setParameters(array $parameters) {
        if (isset($parameters['dir_root'])) {
            $this->dir_root = Paths::sanitize($parameters['dir_root']);
            return true;
        }

        return false;
    }
}