ElggDiskFilestore.php

Go to the documentation of this file.

<?php
class ElggDiskFilestore extends \ElggFilestore {
    private $dir_root;

    const BUCKET_SIZE = 5000;

    private $CONFIG;

    public function __construct($directory_root = "") {
        global $CONFIG;
        $this->CONFIG = $CONFIG;

        if ($directory_root) {
            $this->dir_root = $directory_root;
        } else {
            $this->dir_root = $this->CONFIG->dataroot;
        }
    }

    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 != 'write') && (!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->warn("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:
                $msg = "Unrecognized file mode '" . $mode . "'";
                throw new \InvalidParameterException($msg);
        }

        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) {
        $filename = $this->getFilenameOnFilestore($file);
        if (file_exists($filename)) {
            return unlink($filename);
        } else {
            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) {
            $msg = "File " . $file->getFilename() . " (file guid:" . $file->guid . ") is missing an owner!";
            throw new \InvalidParameterException($msg);
        }

        $filename = $file->getFilename();
        if (!$filename) {
            return '';
        }

        $dir = new \Elgg\EntityDirLocator($owner_guid);

        return $this->dir_root . $dir . $file->getFilename();
    }

    public function grabFile(\ElggFile $file) {
        return file_get_contents($file->getFilenameOnFilestore());
    }

    public function exists(\ElggFile $file) {
        if (!$file->getFilename()) {
            return false;
        }
        return file_exists($this->getFilenameOnFilestore($file));
    }

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

    // @codingStandardsIgnoreStart
    protected function make_directory_root($dirroot) {
        elgg_deprecated_notice('\ElggDiskFilestore::make_directory_root() is deprecated by ::makeDirectoryRoot()', 1.8);

        return $this->makeDirectoryRoot($dirroot);
    }
    // @codingStandardsIgnoreEnd

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

        return true;
    }

    public function getParameters() {
        return array("dir_root" => $this->dir_root);
    }

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

        return false;
    }


    
    // @codingStandardsIgnoreStart
    protected function make_file_matrix($identifier) {
        elgg_deprecated_notice('\ElggDiskFilestore::make_file_matrix() is deprecated by \Elgg\EntityDirLocator', 1.8);

        return $this->makeFileMatrix($identifier);
    }
    // @codingStandardsIgnoreEnd

    // @codingStandardsIgnoreStart
    protected function user_file_matrix($guid) {
        elgg_deprecated_notice('\ElggDiskFilestore::user_file_matrix() is deprecated by \Elgg\EntityDirLocator', 1.8);

        return $this->makeFileMatrix($guid);
    }
    // @codingStandardsIgnoreEnd

    // @codingStandardsIgnoreStart
    private function mb_str_split($string, $charset = 'UTF8') {
        elgg_deprecated_notice('\ElggDiskFilestore::mb_str_split() is deprecated.', 1.8);

        if (is_callable('mb_substr')) {
            $length = mb_strlen($string);
            $array = array();

            while ($length) {
                $array[] = mb_substr($string, 0, 1, $charset);
                $string = mb_substr($string, 1, $length, $charset);

                $length = mb_strlen($string);
            }

            return $array;
        } else {
            return str_split($string);
        }
    }
    // @codingStandardsIgnoreEnd

    protected function makeFileMatrix($guid) {
        elgg_deprecated_notice('\ElggDiskFilestore::makeFileMatrix() is deprecated by \Elgg\EntityDirLocator', 1.9);
        $entity = get_entity($guid);

        if (!$entity instanceof \ElggEntity) {
            return false;
        }

        $dir = new \Elgg\EntityDirLocator($guid);
        return $dir->getPath();
    }
}