open-dsi
/
nextcloud-server
mirror of https://github.com/nextcloud/server
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

remove old filecache

Browse Source
remotes/origin/stable5
Robin Appelman 14 years ago
parent f56aebbd3f
commit d717a5e55c
5 changed files with 2 additions and 826 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 511
      lib/filecache.php
  2. 81
      lib/filecache/cached.php
  3. 217
      lib/filecache/update.php
  4. 12
      lib/filesystem.php
  5. 7
      lib/util.php

511
lib/filecache.php
Unescape View File

@ -1,511 +0,0 @@
<?php
/**
* @author Robin Appelman
* @copyright 2011 Robin Appelman icewind1991@gmail.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/>.
*
*/
/**
* provide caching for filesystem info in the database
*
* not used by OC_Filesystem for reading filesystem info,
* instread apps should use OC_FileCache::get where possible
*
* It will try to keep the data up to date but changes from outside ownCloud can invalidate the cache
*/
class OC_FileCache{
/**
* get the filesystem info from the cache
* @param string path
* @param string root (optional)
* @return array
*
* returns an associative array with the following keys:
* - size
* - mtime
* - ctime
* - mimetype
* - encrypted
* - versioned
*/
public static function get($path,$root=false) {
if(OC_FileCache_Update::hasUpdated($path,$root)) {
if($root===false) {//filesystem hooks are only valid for the default root
OC_Hook::emit('OC_Filesystem','post_write',array('path'=>$path));
}else{
OC_FileCache_Update::update($path,$root);
}
}
return OC_FileCache_Cached::get($path,$root);
}
/**
* put filesystem info in the cache
* @param string $path
* @param array data
* @param string root (optional)
*
* $data is an assiciative array in the same format as returned by get
*/
public static function put($path,$data,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$fullpath=$root.$path;
$parent=self::getParentId($fullpath);
$id=self::getId($fullpath,'');
if(isset(OC_FileCache_Cached::$savedData[$fullpath])) {
$data=array_merge(OC_FileCache_Cached::$savedData[$fullpath],$data);
unset(OC_FileCache_Cached::$savedData[$fullpath]);
}
if($id!=-1) {
self::update($id,$data);
return;
}
// add parent directory to the file cache if it does not exist yet.
if ($parent == -1 && $fullpath != $root) {
$parentDir = dirname($path);
self::scanFile($parentDir);
$parent = self::getParentId($fullpath);
}
if(!isset($data['size']) or !isset($data['mtime'])) {//save incomplete data for the next time we write it
OC_FileCache_Cached::$savedData[$fullpath]=$data;
return;
}
if(!isset($data['encrypted'])) {
$data['encrypted']=false;
}
if(!isset($data['versioned'])) {
$data['versioned']=false;
}
$mimePart=dirname($data['mimetype']);
$data['size']=(int)$data['size'];
$data['ctime']=(int)$data['mtime'];
$data['writable']=(int)$data['writable'];
$data['encrypted']=(int)$data['encrypted'];
$data['versioned']=(int)$data['versioned'];
$user=OC_User::getUser();
$query=OC_DB::prepare('INSERT INTO `*PREFIX*fscache`(`parent`, `name`, `path`, `path_hash`, `size`, `mtime`, `ctime`, `mimetype`, `mimepart`,`user`,`writable`,`encrypted`,`versioned`) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)');
$result=$query->execute(array($parent,basename($fullpath),$fullpath,md5($fullpath),$data['size'],$data['mtime'],$data['ctime'],$data['mimetype'],$mimePart,$user,$data['writable'],$data['encrypted'],$data['versioned']));
if(OC_DB::isError($result)) {
OC_Log::write('files','error while writing file('.$fullpath.') to cache',OC_Log::ERROR);
}
if($cache=OC_Cache::getUserCache(true)) {
$cache->remove('fileid/'.$fullpath);//ensure we don't have -1 cached
}
}
/**
* update filesystem info of a file
* @param int $id
* @param array $data
*/
private static function update($id,$data) {
$arguments=array();
$queryParts=array();
foreach(array('size','mtime','ctime','mimetype','encrypted','versioned','writable') as $attribute) {
if(isset($data[$attribute])) {
//Convert to int it args are false
if($data[$attribute] === false) {
$arguments[] = 0;
}else{
$arguments[] = $data[$attribute];
}
$queryParts[]='`'.$attribute.'`=?';
}
}
if(isset($data['mimetype'])) {
$arguments[]=dirname($data['mimetype']);
$queryParts[]='`mimepart`=?';
}
$arguments[]=$id;
$sql = 'UPDATE `*PREFIX*fscache` SET '.implode(' , ',$queryParts).' WHERE `id`=?';
$query=OC_DB::prepare($sql);
$result=$query->execute($arguments);
if(OC_DB::isError($result)) {
OC_Log::write('files','error while updating file('.$id.') in cache',OC_Log::ERROR);
}
}
/**
* register a file move in the cache
* @param string oldPath
* @param string newPath
* @param string root (optional)
*/
public static function move($oldPath,$newPath,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
// If replacing an existing file, delete the file
if (self::inCache($newPath, $root)) {
self::delete($newPath, $root);
}
$oldPath=$root.$oldPath;
$newPath=$root.$newPath;
$newParent=self::getParentId($newPath);
$query=OC_DB::prepare('UPDATE `*PREFIX*fscache` SET `parent`=? ,`name`=?, `path`=?, `path_hash`=? WHERE `path_hash`=?');
$query->execute(array($newParent,basename($newPath),$newPath,md5($newPath),md5($oldPath)));
if(($cache=OC_Cache::getUserCache(true)) && $cache->hasKey('fileid/'.$oldPath)) {
$cache->set('fileid/'.$newPath,$cache->get('fileid/'.$oldPath));
$cache->remove('fileid/'.$oldPath);
}
$query=OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `path` LIKE ?');
$oldLength=strlen($oldPath);
$updateQuery=OC_DB::prepare('UPDATE `*PREFIX*fscache` SET `path`=?, `path_hash`=? WHERE `path_hash`=?');
while($row= $query->execute(array($oldPath.'/%'))->fetchRow()) {
$old=$row['path'];
$new=$newPath.substr($old,$oldLength);
$updateQuery->execute(array($new,md5($new),md5($old)));
if(($cache=OC_Cache::getUserCache(true)) && $cache->hasKey('fileid/'.$old)) {
$cache->set('fileid/'.$new,$cache->get('fileid/'.$old));
$cache->remove('fileid/'.$old);
}
}
}
/**
* delete info from the cache
* @param string path
* @param string root (optional)
*/
public static function delete($path,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$query=OC_DB::prepare('DELETE FROM `*PREFIX*fscache` WHERE `path_hash`=?');
$query->execute(array(md5($root.$path)));
//delete everything inside the folder
$query=OC_DB::prepare('DELETE FROM `*PREFIX*fscache` WHERE `path` LIKE ?');
$query->execute(array($root.$path.'/%'));
OC_Cache::remove('fileid/'.$root.$path);
}
/**
* return array of filenames matching the querty
* @param string $query
* @param boolean $returnData
* @param string root (optional)
* @return array of filepaths
*/
public static function search($search,$returnData=false,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$rootLen=strlen($root);
if(!$returnData) {
$query=OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `name` LIKE ? AND `user`=?');
}else{
$query=OC_DB::prepare('SELECT * FROM `*PREFIX*fscache` WHERE `name` LIKE ? AND `user`=?');
}
$result=$query->execute(array("%$search%",OC_User::getUser()));
$names=array();
while($row=$result->fetchRow()) {
if(!$returnData) {
$names[]=substr($row['path'],$rootLen);
}else{
$row['path']=substr($row['path'],$rootLen);
$names[]=$row;
}
}
return $names;
}
/**
* get all files and folders in a folder
* @param string path
* @param string root (optional)
* @return array
*
* returns an array of assiciative arrays with the following keys:
* - name
* - size
* - mtime
* - ctime
* - mimetype
* - encrypted
* - versioned
*/
public static function getFolderContent($path,$root=false,$mimetype_filter='') {
if(OC_FileCache_Update::hasUpdated($path,$root,true)) {
OC_FileCache_Update::updateFolder($path,$root);
}
return OC_FileCache_Cached::getFolderContent($path,$root,$mimetype_filter);
}
/**
* check if a file or folder is in the cache
* @param string $path
* @param string root (optional)
* @return bool
*/
public static function inCache($path,$root=false) {
return self::getId($path,$root)!=-1;
}
/**
* get the file id as used in the cache
* @param string path
* @param string root (optional)
* @return int
*/
public static function getId($path,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$fullPath=$root.$path;
if(($cache=OC_Cache::getUserCache(true)) && $cache->hasKey('fileid/'.$fullPath)) {
return $cache->get('fileid/'.$fullPath);
}
$query=OC_DB::prepare('SELECT `id` FROM `*PREFIX*fscache` WHERE `path_hash`=?');
$result=$query->execute(array(md5($fullPath)));
if(OC_DB::isError($result)) {
OC_Log::write('files','error while getting file id of '.$path,OC_Log::ERROR);
return -1;
}
$result=$result->fetchRow();
if(is_array($result)) {
$id=$result['id'];
}else{
$id=-1;
}
if($cache=OC_Cache::getUserCache(true)) {
$cache->set('fileid/'.$fullPath,$id);
}
return $id;
}
/**
* get the file path from the id, relative to the home folder of the user
* @param int id
* @param string user (optional)
* @return string
*/
public static function getPath($id,$user='') {
if(!$user) {
$user=OC_User::getUser();
}
$query=OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `id`=? AND `user`=?');
$result=$query->execute(array($id,$user));
$row=$result->fetchRow();
$path=$row['path'];
$root='/'.$user.'/files';
if(substr($path,0,strlen($root))!=$root) {
return false;
}
return substr($path,strlen($root));
}
/**
* get the file id of the parent folder, taking into account '/' has no parent
* @param string $path
* @return int
*/
private static function getParentId($path) {
if($path=='/') {
return -1;
}else{
return self::getId(dirname($path),'');
}
}
/**
* adjust the size of the parent folders
* @param string $path
* @param int $sizeDiff
* @param string root (optinal)
*/
public static function increaseSize($path,$sizeDiff, $root=false) {
if($sizeDiff==0) return;
$id=self::getId($path,$root);
while($id!=-1) {//walk up the filetree increasing the size of all parent folders
$query=OC_DB::prepare('UPDATE `*PREFIX*fscache` SET `size`=`size`+? WHERE `id`=?');
$query->execute(array($sizeDiff,$id));
$id=self::getParentId($path);
$path=dirname($path);
}
}
/**
* recursively scan the filesystem and fill the cache
* @param string $path
* @param OC_EventSource $enventSource (optional)
* @param int count (optional)
* @param string root (optional)
*/
public static function scan($path,$eventSource=false,&$count=0,$root=false) {
if($eventSource) {
$eventSource->send('scanning',array('file'=>$path,'count'=>$count));
}
$lastSend=$count;
// NOTE: Ugly hack to prevent shared files from going into the cache (the source already exists somewhere in the cache)
if (substr($path, 0, 7) == '/Shared') {
return;
}
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
self::scanFile($path,$root);
$dh=$view->opendir($path.'/');
$totalSize=0;
if($dh) {
while (($filename = readdir($dh)) !== false) {
if($filename != '.' and $filename != '..') {
$file=$path.'/'.$filename;
if($view->is_dir($file.'/')) {
self::scan($file,$eventSource,$count,$root);
}else{
$totalSize+=self::scanFile($file,$root);
$count++;
if($count>$lastSend+25 and $eventSource) {
$lastSend=$count;
$eventSource->send('scanning',array('file'=>$path,'count'=>$count));
}
}
}
}
}
OC_FileCache_Update::cleanFolder($path,$root);
self::increaseSize($path,$totalSize,$root);
}
/**
* scan a single file
* @param string path
* @param string root (optional)
* @return int size of the scanned file
*/
public static function scanFile($path,$root=false) {
// NOTE: Ugly hack to prevent shared files from going into the cache (the source already exists somewhere in the cache)
if (substr($path, 0, 7) == '/Shared') {
return;
}
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
if(!$view->is_readable($path)) return; //cant read, nothing we can do
clearstatcache();
$mimetype=$view->getMimeType($path);
$stat=$view->stat($path);
if($mimetype=='httpd/unix-directory') {
$stat['size'] = 0;
$writable=$view->is_writable($path.'/');
}else{
$writable=$view->is_writable($path);
}
$stat['mimetype']=$mimetype;
$stat['writable']=$writable;
if($path=='/') {
$path='';
}
self::put($path,$stat,$root);
return $stat['size'];
}
/**
* find files by mimetype
* @param string $part1
* @param string $part2 (optional)
* @param string root (optional)
* @return array of file paths
*
* $part1 and $part2 together form the complete mimetype.
* e.g. searchByMime('text','plain')
*
* seccond mimetype part can be ommited
* e.g. searchByMime('audio')
*/
public static function searchByMime($part1,$part2=null,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$rootLen=strlen($root);
$root .= '%';
$user=OC_User::getUser();
if(!$part2) {
$query=OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `mimepart`=? AND `user`=? AND `path` LIKE ?');
$result=$query->execute(array($part1,$user, $root));
}else{
$query=OC_DB::prepare('SELECT `path` FROM `*PREFIX*fscache` WHERE `mimetype`=? AND `user`=? AND `path` LIKE ? ');
$result=$query->execute(array($part1.'/'.$part2,$user, $root));
}
$names=array();
while($row=$result->fetchRow()) {
$names[]=substr($row['path'],$rootLen);
}
return $names;
}
/**
* clean old pre-path_hash entries
*/
public static function clean() {
$query=OC_DB::prepare('DELETE FROM `*PREFIX*fscache` WHERE LENGTH(`path_hash`)<30');
$query->execute();
}
/**
* clear filecache entries
* @param string user (optonal)
*/
public static function clear($user='') {
if($user) {
$query=OC_DB::prepare('DELETE FROM `*PREFIX*fscache` WHERE `user`=?');
$query->execute(array($user));
}else{
$query=OC_DB::prepare('DELETE FROM `*PREFIX*fscache`');
$query->execute();
}
}
/**
* trigger an update for the cache by setting the mtimes to 0
* @param string $user (optional)
*/
public static function triggerUpdate($user=''){
if($user) {
$query=OC_DB::prepare('UPDATE `*PREFIX*fscache` SET `mtime`=0 WHERE `user`=? AND `mimetype`="httpd/unix-directory"');
$query->execute(array($user));
}else{
$query=OC_DB::prepare('UPDATE `*PREFIX*fscache` SET `mtime`=0 AND `mimetype`="httpd/unix-directory"');
$query->execute();
}
}
}
//watch for changes and try to keep the cache up to date
OC_Hook::connect('OC_Filesystem','post_write','OC_FileCache_Update','fileSystemWatcherWrite');
OC_Hook::connect('OC_Filesystem','post_delete','OC_FileCache_Update','fileSystemWatcherDelete');
OC_Hook::connect('OC_Filesystem','post_rename','OC_FileCache_Update','fileSystemWatcherRename');

81
lib/filecache/cached.php vendored
Unescape View File

@ -1,81 +0,0 @@
<?php
/**
* Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
* This file is licensed under the Affero General Public License version 3 or
* later.
* See the COPYING-README file.
*/
/**
* get data from the filecache without checking for updates
*/
class OC_FileCache_Cached{
public static $savedData=array();
public static function get($path,$root=false) {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$path=$root.$path;
$stmt=OC_DB::prepare('SELECT `path`,`ctime`,`mtime`,`mimetype`,`size`,`encrypted`,`versioned`,`writable` FROM `*PREFIX*fscache` WHERE `path_hash`=?');
if ( ! OC_DB::isError($stmt) ) {
$result=$stmt->execute(array(md5($path)));
if ( ! OC_DB::isError($result) ) {
$result = $result->fetchRow();
} else {
OC:Log::write('OC_FileCache_Cached', 'could not execute get: '. OC_DB::getErrorMessage($result), OC_Log::ERROR);
$result = false;
}
} else {
OC_Log::write('OC_FileCache_Cached', 'could not prepare get: '. OC_DB::getErrorMessage($stmt), OC_Log::ERROR);
$result = false;
}
if(is_array($result)) {
if(isset(self::$savedData[$path])) {
$result=array_merge($result, self::$savedData[$path]);
}
return $result;
}else{
if(isset(self::$savedData[$path])) {
return self::$savedData[$path];
}else{
return array();
}
}
}
/**
* get all files and folders in a folder
* @param string path
* @param string root (optional)
* @return array
*
* returns an array of assiciative arrays with the following keys:
* - path
* - name
* - size
* - mtime
* - ctime
* - mimetype
* - encrypted
* - versioned
*/
public static function getFolderContent($path,$root=false,$mimetype_filter='') {
if($root===false) {
$root=OC_Filesystem::getRoot();
}
$parent=OC_FileCache::getId($path, $root);
if($parent==-1) {
return array();
}
$query=OC_DB::prepare('SELECT `id`,`path`,`name`,`ctime`,`mtime`,`mimetype`,`size`,`encrypted`,`versioned`,`writable` FROM `*PREFIX*fscache` WHERE `parent`=? AND (`mimetype` LIKE ? OR `mimetype` = ?)');
$result=$query->execute(array($parent, $mimetype_filter.'%', 'httpd/unix-directory'))->fetchAll();
if(is_array($result)) {
return $result;
}else{
OC_Log::write('files', 'getFolderContent(): file not found in cache ('.$path.')', OC_Log::DEBUG);
return false;
}
}
}

217
lib/filecache/update.php vendored
Unescape View File

@ -1,217 +0,0 @@
<?php
/**
* Copyright (c) 2012 Robin Appelman <icewind@owncloud.com>
* This file is licensed under the Affero General Public License version 3 or
* later.
* See the COPYING-README file.
*/
/**
* handles updating the filecache according to outside changes
*/
class OC_FileCache_Update{
/**
* check if a file or folder is updated outside owncloud
* @param string path
* @param string root (optional)
* @param boolean folder
* @return bool
*/
public static function hasUpdated($path,$root=false,$folder=false) {
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
if(!$view->file_exists($path)) {
return false;
}
$cachedData=OC_FileCache_Cached::get($path, $root);
if(isset($cachedData['mtime'])) {
$cachedMTime=$cachedData['mtime'];
if($folder) {
return $view->hasUpdated($path.'/', $cachedMTime);
}else{
return $view->hasUpdated($path, $cachedMTime);
}
}else{//file not in cache, so it has to be updated
if(($path=='/' or $path=='') and $root===false) {//dont auto update the home folder, it will be scanned
return false;
}
return true;
}
}
/**
* delete non existing files from the cache
*/
public static function cleanFolder($path,$root=false) {
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
$cachedContent=OC_FileCache_Cached::getFolderContent($path,$root);
foreach($cachedContent as $fileData) {
$path=$fileData['path'];
$file=$view->getRelativePath($path);
if(!$view->file_exists($file)) {
if($root===false) {//filesystem hooks are only valid for the default root
OC_Hook::emit('OC_Filesystem', 'post_delete', array('path'=>$file));
}else{
self::delete($file, $root);
}
}
}
}
/**
* update the cache according to changes in the folder
* @param string path
* @param string root (optional)
*/
public static function updateFolder($path,$root=false) {
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
$dh=$view->opendir($path.'/');
if($dh) {//check for changed/new files
while (($filename = readdir($dh)) !== false) {
if($filename != '.' and $filename != '..' and $filename != '') {
$file=$path.'/'.$filename;
$isDir=$view->is_dir($file);
if(self::hasUpdated($file, $root, $isDir)) {
if($isDir){
self::updateFolder($file, $root);
}elseif($root===false) {//filesystem hooks are only valid for the default root
OC_Hook::emit('OC_Filesystem', 'post_write', array('path'=>$file));
}else{
self::update($file, $root);
}
}
}
}
}
self::cleanFolder($path, $root);
//update the folder last, so we can calculate the size correctly
if($root===false) {//filesystem hooks are only valid for the default root
OC_Hook::emit('OC_Filesystem', 'post_write', array('path'=>$path));
}else{
self::update($path, $root);
}
}
/**
* called when changes are made to files
* @param array $params
* @param string root (optional)
*/
public static function fileSystemWatcherWrite($params) {
$path=$params['path'];
self::update($path);
}
/**
* called when files are deleted
* @param array $params
* @param string root (optional)
*/
public static function fileSystemWatcherDelete($params) {
$path=$params['path'];
self::delete($path);
}
/**
* called when files are deleted
* @param array $params
* @param string root (optional)
*/
public static function fileSystemWatcherRename($params) {
$oldPath=$params['oldpath'];
$newPath=$params['newpath'];
self::rename($oldPath, $newPath);
}
/**
* update the filecache according to changes to the filesystem
* @param string path
* @param string root (optional)
*/
public static function update($path,$root=false) {
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
$mimetype=$view->getMimeType($path);
$size=0;
$cached=OC_FileCache_Cached::get($path,$root);
$cachedSize=isset($cached['size'])?$cached['size']:0;
if($view->is_dir($path.'/')) {
if(OC_FileCache::inCache($path, $root)) {
$cachedContent=OC_FileCache_Cached::getFolderContent($path, $root);
foreach($cachedContent as $file) {
$size+=$file['size'];
}
$mtime=$view->filemtime($path.'/');
$ctime=$view->filectime($path.'/');
$writable=$view->is_writable($path.'/');
OC_FileCache::put($path, array('size'=>$size,'mtime'=>$mtime,'ctime'=>$ctime,'mimetype'=>$mimetype,'writable'=>$writable));
}else{
$count=0;
OC_FileCache::scan($path, null, $count, $root);
return; //increaseSize is already called inside scan
}
}else{
$size=OC_FileCache::scanFile($path, $root);
}
OC_FileCache::increaseSize(dirname($path), $size-$cachedSize, $root);
}
/**
* update the filesystem after a delete has been detected
* @param string path
* @param string root (optional)
*/
public static function delete($path,$root=false) {
$cached=OC_FileCache_Cached::get($path, $root);
if(!isset($cached['size'])) {
return;
}
$size=$cached['size'];
OC_FileCache::increaseSize(dirname($path), -$size, $root);
OC_FileCache::delete($path, $root);
}
/**
* update the filesystem after a rename has been detected
* @param string oldPath
* @param string newPath
* @param string root (optional)
*/
public static function rename($oldPath,$newPath,$root=false) {
if(!OC_FileCache::inCache($oldPath, $root)) {
return;
}
if($root===false) {
$view=OC_Filesystem::getView();
}else{
$view=new OC_FilesystemView($root);
}
$cached=OC_FileCache_Cached::get($oldPath, $root);
$oldSize=$cached['size'];
OC_FileCache::increaseSize(dirname($oldPath), -$oldSize, $root);
OC_FileCache::increaseSize(dirname($newPath), $oldSize, $root);
OC_FileCache::move($oldPath, $newPath);
}
}

12
lib/filesystem.php
Unescape View File

@ -254,13 +254,6 @@ class OC_Filesystem{
}
}
}
$mtime=filemtime(OC::$SERVERROOT.'/config/mount.php');
$previousMTime=OC_Appconfig::getValue('files','mountconfigmtime',0);
if($mtime>$previousMTime) {//mount config has changed, filecache needs to be updated
OC_FileCache::triggerUpdate();
OC_Appconfig::setValue('files','mountconfigmtime',$mtime);
}
}
self::$loaded=true;
@ -399,7 +392,7 @@ class OC_Filesystem{
}
/**
* checks if a file is blacklsited for storage in the filesystem
* checks if a file is blacklisted for storage in the filesystem
* Listens to write and rename hooks
* @param array $data from hook
*/
@ -419,7 +412,7 @@ class OC_Filesystem{
}
/**
* following functions are equivilent to their php buildin equivilents for arguments/return values.
* following functions are equivalent to their php builtin equivalents for arguments/return values.
*/
static public function mkdir($path) {
return self::$defaultInstance->mkdir($path);
@ -592,4 +585,3 @@ OC_Hook::connect('OC_Filesystem','post_delete','OC_Filesystem','removeETagHook')
OC_Hook::connect('OC_Filesystem','post_rename','OC_Filesystem','removeETagHook');
OC_Util::setupFS();
require_once 'filecache.php';

7
lib/util.php
Unescape View File

@ -58,13 +58,6 @@ class OC_Util {
OC_Filesystem::mount($options['class'], $options['options'], $mountPoint);
}
}
$mtime=filemtime($user_root.'/mount.php');
$previousMTime=OC_Preferences::getValue($user,'files','mountconfigmtime',0);
if($mtime>$previousMTime) {//mount config has changed, filecache needs to be updated
OC_FileCache::triggerUpdate($user);
OC_Preferences::setValue($user,'files','mountconfigmtime',$mtime);
}
}
OC_Hook::emit('OC_Filesystem', 'setup', array('user' => $user, 'user_dir' => $user_dir));
}

Write Preview
Loading…
Cancel
Save