path: root/apps/files_versioning/versionstorage.php

<?php
/**
 * ownCloud file storage implementation for Git repositories
 * @author Craig Roberts
 * @copyright 2012 Craig Roberts craig0990@googlemail.com
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU AFFERO GENERAL PUBLIC LICENSE for more details.
 *
 * You should have received a copy of the GNU Affero General Public
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */

// Include Granite
require_once('lib_granite.php');

// Create a top-level 'Backup' directory if it does not already exist
$user = OC_User::getUser();
if (OC_Filesystem::$loaded and !OC_Filesystem::is_dir('/Backup')) {
    OC_Filesystem::mkdir('/Backup');
    OC_Preferences::setValue(OC_User::getUser(), 'files_versioning', 'head', 'HEAD');
}

// Generate the repository path (currently using 'full' repositories, as opposed to bare ones)
$repo_path = DIRECTORY_SEPARATOR
    . OC_User::getUser()
    . DIRECTORY_SEPARATOR
    . 'files'
    . DIRECTORY_SEPARATOR
    . 'Backup';

// Mount the 'Backup' folder using the versioned storage provider below
OC_Filesystem::mount('OC_Filestorage_Versioned', array('repo'=>$repo_path), $repo_path . DIRECTORY_SEPARATOR);

class OC_Filestorage_Versioned extends OC_Filestorage {

    /**
     * Holds an instance of Granite\Git\Repository
     */
    protected $repo;

    /**
     * Constructs a new OC_Filestorage_Versioned instance, expects an associative
     * array with a `repo` key set to the path of the repository's `.git` folder
     *
     * @param array $parameters An array containing the key `repo` pointing to the
     *                             repository path.
     */
    public function __construct($parameters) {
        // Get the full path to the repository folder
        $path = OC_Config::getValue('datadirectory', OC::$SERVERROOT.'/data')
                . $parameters['repo']
                . DIRECTORY_SEPARATOR
                . '.git'
                . DIRECTORY_SEPARATOR;

        try {
            // Attempt to load the repository
            $this->repo = new Granite\Git\Repository($path);
        } catch (InvalidArgumentException $e) {
            // $path is not a valid Git repository, we must create one
            Granite\Git\Repository::init($path);

            // Load the newly-initialised repository
            $this->repo = new Granite\Git\Repository($path);

            /**
             * Create an initial commit with a README file
             * FIXME: This functionality should be transferred to the Granite library
             */
            $blob = new Granite\Git\Blob($this->repo->path());
            $blob->content('Your Backup directory is now ready for use.');

            // Create a new tree to hold the README file
            $tree = $this->repo->factory('tree');
            // Create a tree node to represent the README blob
            $tree_node = new Granite\Git\Tree\Node('README', '100644', $blob->sha());
            $tree->nodes(array($tree_node->name() => $tree_node));

            // Create an initial commit
            $commit = new Granite\Git\Commit($this->repo->path());
            $user_string = OC_User::getUser() . ' ' . time() . ' +0000';
            $commit->author($user_string);
            $commit->committer($user_string);
            $commit->message('Initial commit');
            $commit->tree($tree);

            // Write it all to disk
            $blob->write();
            $tree->write();
            $commit->write();

            // Update the HEAD for the 'master' branch
            $this->repo->head('master', $commit->sha());
        }

        // Update the class pointer to the HEAD
        $head = OC_Preferences::getValue(OC_User::getUser(), 'files_versioning', 'head', 'HEAD');

        // Load the most recent commit if the preference is not set
        if ($head == 'HEAD') {
            $this->head = $this->repo->head()->sha();
        } else {
            $this->head = $head;
        }
    }

    public function mkdir($path) {
        if (mkdir("versioned:/{$this->repo->path()}$path#{$this->head}")) {
            $this->head = $this->repo->head()->sha();
            OC_Preferences::setValue(OC_User::getUser(), 'files_versioning', 'head', $head);
            return true;
        }

        return false;
    }

    public function rmdir($path) {

    }

    /**
     * Returns a directory handle to the requested path, or FALSE on failure
     *
     * @param string $path The directory path to open
     *
     * @return boolean|resource A directory handle, or FALSE on failure
     */
    public function opendir($path) {
        return opendir("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    /**
     * Returns TRUE if $path is a directory, or FALSE if not
     *
     * @param string $path The path to check
     *
     * @return boolean
     */
    public function is_dir($path) {
        return $this->filetype($path) == 'dir';
    }

    /**
     * Returns TRUE if $path is a file, or FALSE if not
     *
     * @param string $path The path to check
     *
     * @return boolean
     */
    public function is_file($path) {
        return $this->filetype($path) == 'file';
    }

    public function stat($path)
	{
	    return stat("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    /**
     * Returns the strings 'dir' or 'file', depending on the type of $path
     *
     * @param string $path The path to check
     *
     * @return string Returns 'dir' if a directory, 'file' otherwise
     */
    public function filetype($path) {
	    if ($path == "" || $path == "/") {
	        return 'dir';
        } else {
            if (substr($path, -1) == '/') {
                $path = substr($path, 0, -1);
            }

            $node = $this->tree_search($this->repo, $this->repo->factory('commit', $this->head)->tree(), $path);

            // Does it exist, or is it new?
            if ($node == null) {
                // New file
                return 'file';
            } else {
                // Is it a tree?
                try {
                    $this->repo->factory('tree', $node);
                    return 'dir';
                } catch (InvalidArgumentException $e) {
                    // Nope, must be a blob
                    return 'file';
                }
            }
        }
    }

    public function filesize($path) {
        return filesize("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    /**
     * Returns a boolean value representing whether $path is readable
     *
     * @param string $path The path to check
     *(
     * @return boolean Whether or not the path is readable
     */
    public function is_readable($path) {
        return true;
    }

    /**
     * Returns a boolean value representing whether $path is writable
     *
     * @param string $path The path to check
     *(
     * @return boolean Whether or not the path is writable
     */
    public function is_writable($path) {

        $head = OC_Preferences::getValue(OC_User::getUser(), 'files_versioning', 'head', 'HEAD');
        if ($head !== 'HEAD' && $head !== $this->repo->head()->sha()) {
            // Cannot modify previous commits
            return false;
        }
        return true;
    }

    /**
     * Returns a boolean value representing whether $path exists
     *
     * @param string $path The path to check
     *(
     * @return boolean Whether or not the path exists
     */
    public function file_exists($path) {
        return file_exists("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    /**
     * Returns an integer value representing the inode change time
     * (NOT IMPLEMENTED)
     *
     * @param string $path The path to check
     *(
     * @return int Timestamp of the last inode change
     */
    public function filectime($path) {
        return -1;
    }

    /**
     * Returns an integer value representing the file modification time
     *
     * @param string $path The path to check
     *(
     * @return int Timestamp of the last file modification
     */
    public function filemtime($path) {
        return filemtime("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    public function file_get_contents($path) {
        return file_get_contents("versioned:/{$this->repo->path()}$path#{$this->head}");
    }

    public function file_put_contents($path, $data) {
        $success = file_put_contents("versioned:/{$this->repo->path()}$path#{$this->head}", $data);
        if ($success !== false) {
            // Update the HEAD in the preferences
            OC_Preferences::setValue(OC_User::getUser(), 'files_versioning', 'head', $this->repo->head()->sha());
            return $success;
        }

        return false;
    }

    public function unlink($path) {

    }

    public function rename($path1, $path2) {

    }

    public function copy($path1, $path2) {

    }

    public function fopen($path, $mode) {
	    return fopen("versioned:/{$this->repo->path()}$path#{$this->head}", $mode);
    }

    public function getMimeType($path) {
        if ($this->filetype($path) == 'dir') {
	        return 'httpd/unix-directory';
	    } elseif ($this->filesize($path) == 0) {
	        // File's empty, returning text/plain allows opening in the web editor
	        return 'text/plain';
	    } else {
            $finfo = new finfo(FILEINFO_MIME_TYPE);
            /**
             * We need to represent the repository path, the file path, and the
             * revision, which can be simply achieved with a convention of using
             * `.git` in the repository directory (bare or not) and the '#part'
             * segment of a URL to specify the revision. For example
             *
             * versioned://var/www/myrepo.git/docs/README.md#HEAD ('bare' repo)
             * versioned://var/www/myrepo/.git/docs/README.md#HEAD ('full' repo)
             * versioned://var/www/myrepo/.git/docs/README.md#6a8f...8a54 ('full' repo and SHA-1 commit ID)
             */
            $mime = $finfo->buffer(file_get_contents("versioned:/{$this->repo->path()}$path#{$this->head}"));
            return $mime;
	    }
    }

    /**
     * Generates a hash based on the file contents
     *
     * @param string $type The hashing algorithm to use (e.g. 'md5', 'sha256', etc.)
     * @param string $path The file to be hashed
     * @param boolean $raw Outputs binary data if true, lowercase hex digits otherwise
     *
     * @return string Hashed string representing the file contents
     */
    public function hash($type, $path, $raw) {
        return hash($type, file_get_contents($path), $raw);
    }

    public function free_space($path) {
    }

    public function search($query) {

    }

    public function touch($path, $mtime=null) {

    }


    public function getLocalFile($path) {
    }

    /**
     * Recursively searches a tree for a path, returning FALSE if is not found
     * or an SHA-1 id if it is found.
     *
     * @param string  $repo  The repository containing the tree object
     * @param string  $tree  The tree object to search
     * @param string  $path  The path to search for (relative to the tree)
     * @param int     $depth The depth of the current search (for recursion)
     *
     * @return string|boolean The SHA-1 id of the sub-tree
     */
    private function tree_search($repo, $tree, $path, $depth = 0)
    {
        $paths = array_values(explode(DIRECTORY_SEPARATOR, $path));

        $current_path = $paths[$depth];

        $nodes = $tree->nodes();
        foreach ($nodes as $node) {
            if ($node->name() == $current_path) {

                if (count($paths)-1 == $depth) {
                    // Stop, found it
                    return $node->sha();
                }

                // Recurse if necessary
                if ($node->isDirectory()) {
                    $tree = $this->repo->factory('tree', $node->sha());
                    return $this->tree_search($repo, $tree, $path, $depth + 1);
                }
            }
        }

        return false;
    }

}