@@ -39,6 +39,6 @@ |
||
39 | 39 | */ |
40 | 40 | public function getHomeMountForUser(IUser $user, IStorageFactory $loader) { |
41 | 41 | $arguments = ['user' => $user]; |
42 | - return new MountPoint('\OC\Files\Storage\Home', '/' . $user->getUID(), $arguments, $loader); |
|
42 | + return new MountPoint('\OC\Files\Storage\Home', '/'.$user->getUID(), $arguments, $loader); |
|
43 | 43 | } |
44 | 44 | } |
@@ -30,15 +30,15 @@ |
||
30 | 30 | * Mount provider for regular posix home folders |
31 | 31 | */ |
32 | 32 | class LocalHomeMountProvider implements IHomeMountProvider { |
33 | - /** |
|
34 | - * Get the cache mount for a user |
|
35 | - * |
|
36 | - * @param IUser $user |
|
37 | - * @param IStorageFactory $loader |
|
38 | - * @return \OCP\Files\Mount\IMountPoint|null |
|
39 | - */ |
|
40 | - public function getHomeMountForUser(IUser $user, IStorageFactory $loader) { |
|
41 | - $arguments = ['user' => $user]; |
|
42 | - return new MountPoint('\OC\Files\Storage\Home', '/' . $user->getUID(), $arguments, $loader); |
|
43 | - } |
|
33 | + /** |
|
34 | + * Get the cache mount for a user |
|
35 | + * |
|
36 | + * @param IUser $user |
|
37 | + * @param IStorageFactory $loader |
|
38 | + * @return \OCP\Files\Mount\IMountPoint|null |
|
39 | + */ |
|
40 | + public function getHomeMountForUser(IUser $user, IStorageFactory $loader) { |
|
41 | + $arguments = ['user' => $user]; |
|
42 | + return new MountPoint('\OC\Files\Storage\Home', '/' . $user->getUID(), $arguments, $loader); |
|
43 | + } |
|
44 | 44 | } |
@@ -27,19 +27,19 @@ |
||
27 | 27 | * Defines the mount point to be (re)moved by the user |
28 | 28 | */ |
29 | 29 | interface MoveableMount { |
30 | - /** |
|
31 | - * Move the mount point to $target |
|
32 | - * |
|
33 | - * @param string $target the target mount point |
|
34 | - * @return bool |
|
35 | - */ |
|
36 | - public function moveMount($target); |
|
30 | + /** |
|
31 | + * Move the mount point to $target |
|
32 | + * |
|
33 | + * @param string $target the target mount point |
|
34 | + * @return bool |
|
35 | + */ |
|
36 | + public function moveMount($target); |
|
37 | 37 | |
38 | - /** |
|
39 | - * Remove the mount points |
|
40 | - * |
|
41 | - * @return mixed |
|
42 | - * @return bool |
|
43 | - */ |
|
44 | - public function removeMount(); |
|
38 | + /** |
|
39 | + * Remove the mount points |
|
40 | + * |
|
41 | + * @return mixed |
|
42 | + * @return bool |
|
43 | + */ |
|
44 | + public function removeMount(); |
|
45 | 45 | } |
@@ -29,60 +29,60 @@ |
||
29 | 29 | use OCP\IUser; |
30 | 30 | |
31 | 31 | class LazyStorageMountInfo extends CachedMountInfo { |
32 | - /** @var IMountPoint */ |
|
33 | - private $mount; |
|
32 | + /** @var IMountPoint */ |
|
33 | + private $mount; |
|
34 | 34 | |
35 | - /** |
|
36 | - * CachedMountInfo constructor. |
|
37 | - * |
|
38 | - * @param IUser $user |
|
39 | - * @param IMountPoint $mount |
|
40 | - */ |
|
41 | - public function __construct(IUser $user, IMountPoint $mount) { |
|
42 | - $this->user = $user; |
|
43 | - $this->mount = $mount; |
|
44 | - } |
|
35 | + /** |
|
36 | + * CachedMountInfo constructor. |
|
37 | + * |
|
38 | + * @param IUser $user |
|
39 | + * @param IMountPoint $mount |
|
40 | + */ |
|
41 | + public function __construct(IUser $user, IMountPoint $mount) { |
|
42 | + $this->user = $user; |
|
43 | + $this->mount = $mount; |
|
44 | + } |
|
45 | 45 | |
46 | - /** |
|
47 | - * @return int the numeric storage id of the mount |
|
48 | - */ |
|
49 | - public function getStorageId() { |
|
50 | - if (!$this->storageId) { |
|
51 | - $this->storageId = $this->mount->getNumericStorageId(); |
|
52 | - } |
|
53 | - return parent::getStorageId(); |
|
54 | - } |
|
46 | + /** |
|
47 | + * @return int the numeric storage id of the mount |
|
48 | + */ |
|
49 | + public function getStorageId() { |
|
50 | + if (!$this->storageId) { |
|
51 | + $this->storageId = $this->mount->getNumericStorageId(); |
|
52 | + } |
|
53 | + return parent::getStorageId(); |
|
54 | + } |
|
55 | 55 | |
56 | - /** |
|
57 | - * @return int the fileid of the root of the mount |
|
58 | - */ |
|
59 | - public function getRootId() { |
|
60 | - if (!$this->rootId) { |
|
61 | - $this->rootId = $this->mount->getStorageRootId(); |
|
62 | - } |
|
63 | - return parent::getRootId(); |
|
64 | - } |
|
56 | + /** |
|
57 | + * @return int the fileid of the root of the mount |
|
58 | + */ |
|
59 | + public function getRootId() { |
|
60 | + if (!$this->rootId) { |
|
61 | + $this->rootId = $this->mount->getStorageRootId(); |
|
62 | + } |
|
63 | + return parent::getRootId(); |
|
64 | + } |
|
65 | 65 | |
66 | - /** |
|
67 | - * @return string the mount point of the mount for the user |
|
68 | - */ |
|
69 | - public function getMountPoint() { |
|
70 | - if (!$this->mountPoint) { |
|
71 | - $this->mountPoint = $this->mount->getMountPoint(); |
|
72 | - } |
|
73 | - return parent::getMountPoint(); |
|
74 | - } |
|
66 | + /** |
|
67 | + * @return string the mount point of the mount for the user |
|
68 | + */ |
|
69 | + public function getMountPoint() { |
|
70 | + if (!$this->mountPoint) { |
|
71 | + $this->mountPoint = $this->mount->getMountPoint(); |
|
72 | + } |
|
73 | + return parent::getMountPoint(); |
|
74 | + } |
|
75 | 75 | |
76 | - public function getMountId() { |
|
77 | - return $this->mount->getMountId(); |
|
78 | - } |
|
76 | + public function getMountId() { |
|
77 | + return $this->mount->getMountId(); |
|
78 | + } |
|
79 | 79 | |
80 | - /** |
|
81 | - * Get the internal path (within the storage) of the root of the mount |
|
82 | - * |
|
83 | - * @return string |
|
84 | - */ |
|
85 | - public function getRootInternalPath() { |
|
86 | - return $this->mount->getInternalPath($this->mount->getMountPoint()); |
|
87 | - } |
|
80 | + /** |
|
81 | + * Get the internal path (within the storage) of the root of the mount |
|
82 | + * |
|
83 | + * @return string |
|
84 | + */ |
|
85 | + public function getRootInternalPath() { |
|
86 | + return $this->mount->getInternalPath($this->mount->getMountPoint()); |
|
87 | + } |
|
88 | 88 | } |
@@ -29,21 +29,21 @@ |
||
29 | 29 | * Listen to hooks and update the mount cache as needed |
30 | 30 | */ |
31 | 31 | class UserMountCacheListener { |
32 | - /** |
|
33 | - * @var IUserMountCache |
|
34 | - */ |
|
35 | - private $userMountCache; |
|
32 | + /** |
|
33 | + * @var IUserMountCache |
|
34 | + */ |
|
35 | + private $userMountCache; |
|
36 | 36 | |
37 | - /** |
|
38 | - * UserMountCacheListener constructor. |
|
39 | - * |
|
40 | - * @param IUserMountCache $userMountCache |
|
41 | - */ |
|
42 | - public function __construct(IUserMountCache $userMountCache) { |
|
43 | - $this->userMountCache = $userMountCache; |
|
44 | - } |
|
37 | + /** |
|
38 | + * UserMountCacheListener constructor. |
|
39 | + * |
|
40 | + * @param IUserMountCache $userMountCache |
|
41 | + */ |
|
42 | + public function __construct(IUserMountCache $userMountCache) { |
|
43 | + $this->userMountCache = $userMountCache; |
|
44 | + } |
|
45 | 45 | |
46 | - public function listen(Manager $manager) { |
|
47 | - $manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']); |
|
48 | - } |
|
46 | + public function listen(Manager $manager) { |
|
47 | + $manager->listen('\OC\User', 'postDelete', [$this->userMountCache, 'removeUserMounts']); |
|
48 | + } |
|
49 | 49 | } |
@@ -28,114 +28,114 @@ |
||
28 | 28 | use OCP\IUser; |
29 | 29 | |
30 | 30 | class CachedMountInfo implements ICachedMountInfo { |
31 | - /** |
|
32 | - * @var IUser |
|
33 | - */ |
|
34 | - protected $user; |
|
35 | - |
|
36 | - /** |
|
37 | - * @var int |
|
38 | - */ |
|
39 | - protected $storageId; |
|
40 | - |
|
41 | - /** |
|
42 | - * @var int |
|
43 | - */ |
|
44 | - protected $rootId; |
|
45 | - |
|
46 | - /** |
|
47 | - * @var string |
|
48 | - */ |
|
49 | - protected $mountPoint; |
|
50 | - |
|
51 | - /** |
|
52 | - * @var int|null |
|
53 | - */ |
|
54 | - protected $mountId; |
|
55 | - |
|
56 | - /** |
|
57 | - * @var string |
|
58 | - */ |
|
59 | - protected $rootInternalPath; |
|
60 | - |
|
61 | - /** |
|
62 | - * CachedMountInfo constructor. |
|
63 | - * |
|
64 | - * @param IUser $user |
|
65 | - * @param int $storageId |
|
66 | - * @param int $rootId |
|
67 | - * @param string $mountPoint |
|
68 | - * @param int|null $mountId |
|
69 | - * @param string $rootInternalPath |
|
70 | - */ |
|
71 | - public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') { |
|
72 | - $this->user = $user; |
|
73 | - $this->storageId = $storageId; |
|
74 | - $this->rootId = $rootId; |
|
75 | - $this->mountPoint = $mountPoint; |
|
76 | - $this->mountId = $mountId; |
|
77 | - $this->rootInternalPath = $rootInternalPath; |
|
78 | - } |
|
79 | - |
|
80 | - /** |
|
81 | - * @return IUser |
|
82 | - */ |
|
83 | - public function getUser() { |
|
84 | - return $this->user; |
|
85 | - } |
|
86 | - |
|
87 | - /** |
|
88 | - * @return int the numeric storage id of the mount |
|
89 | - */ |
|
90 | - public function getStorageId() { |
|
91 | - return $this->storageId; |
|
92 | - } |
|
93 | - |
|
94 | - /** |
|
95 | - * @return int the fileid of the root of the mount |
|
96 | - */ |
|
97 | - public function getRootId() { |
|
98 | - return $this->rootId; |
|
99 | - } |
|
100 | - |
|
101 | - /** |
|
102 | - * @return Node the root node of the mount |
|
103 | - */ |
|
104 | - public function getMountPointNode() { |
|
105 | - // TODO injection etc |
|
106 | - Filesystem::initMountPoints($this->getUser()->getUID()); |
|
107 | - $userNode = \OC::$server->getUserFolder($this->getUser()->getUID()); |
|
108 | - $nodes = $userNode->getParent()->getById($this->getRootId()); |
|
109 | - if (count($nodes) > 0) { |
|
110 | - return $nodes[0]; |
|
111 | - } else { |
|
112 | - return null; |
|
113 | - } |
|
114 | - } |
|
115 | - |
|
116 | - /** |
|
117 | - * @return string the mount point of the mount for the user |
|
118 | - */ |
|
119 | - public function getMountPoint() { |
|
120 | - return $this->mountPoint; |
|
121 | - } |
|
122 | - |
|
123 | - /** |
|
124 | - * Get the id of the configured mount |
|
125 | - * |
|
126 | - * @return int|null mount id or null if not applicable |
|
127 | - * @since 9.1.0 |
|
128 | - */ |
|
129 | - public function getMountId() { |
|
130 | - return $this->mountId; |
|
131 | - } |
|
132 | - |
|
133 | - /** |
|
134 | - * Get the internal path (within the storage) of the root of the mount |
|
135 | - * |
|
136 | - * @return string |
|
137 | - */ |
|
138 | - public function getRootInternalPath() { |
|
139 | - return $this->rootInternalPath; |
|
140 | - } |
|
31 | + /** |
|
32 | + * @var IUser |
|
33 | + */ |
|
34 | + protected $user; |
|
35 | + |
|
36 | + /** |
|
37 | + * @var int |
|
38 | + */ |
|
39 | + protected $storageId; |
|
40 | + |
|
41 | + /** |
|
42 | + * @var int |
|
43 | + */ |
|
44 | + protected $rootId; |
|
45 | + |
|
46 | + /** |
|
47 | + * @var string |
|
48 | + */ |
|
49 | + protected $mountPoint; |
|
50 | + |
|
51 | + /** |
|
52 | + * @var int|null |
|
53 | + */ |
|
54 | + protected $mountId; |
|
55 | + |
|
56 | + /** |
|
57 | + * @var string |
|
58 | + */ |
|
59 | + protected $rootInternalPath; |
|
60 | + |
|
61 | + /** |
|
62 | + * CachedMountInfo constructor. |
|
63 | + * |
|
64 | + * @param IUser $user |
|
65 | + * @param int $storageId |
|
66 | + * @param int $rootId |
|
67 | + * @param string $mountPoint |
|
68 | + * @param int|null $mountId |
|
69 | + * @param string $rootInternalPath |
|
70 | + */ |
|
71 | + public function __construct(IUser $user, $storageId, $rootId, $mountPoint, $mountId = null, $rootInternalPath = '') { |
|
72 | + $this->user = $user; |
|
73 | + $this->storageId = $storageId; |
|
74 | + $this->rootId = $rootId; |
|
75 | + $this->mountPoint = $mountPoint; |
|
76 | + $this->mountId = $mountId; |
|
77 | + $this->rootInternalPath = $rootInternalPath; |
|
78 | + } |
|
79 | + |
|
80 | + /** |
|
81 | + * @return IUser |
|
82 | + */ |
|
83 | + public function getUser() { |
|
84 | + return $this->user; |
|
85 | + } |
|
86 | + |
|
87 | + /** |
|
88 | + * @return int the numeric storage id of the mount |
|
89 | + */ |
|
90 | + public function getStorageId() { |
|
91 | + return $this->storageId; |
|
92 | + } |
|
93 | + |
|
94 | + /** |
|
95 | + * @return int the fileid of the root of the mount |
|
96 | + */ |
|
97 | + public function getRootId() { |
|
98 | + return $this->rootId; |
|
99 | + } |
|
100 | + |
|
101 | + /** |
|
102 | + * @return Node the root node of the mount |
|
103 | + */ |
|
104 | + public function getMountPointNode() { |
|
105 | + // TODO injection etc |
|
106 | + Filesystem::initMountPoints($this->getUser()->getUID()); |
|
107 | + $userNode = \OC::$server->getUserFolder($this->getUser()->getUID()); |
|
108 | + $nodes = $userNode->getParent()->getById($this->getRootId()); |
|
109 | + if (count($nodes) > 0) { |
|
110 | + return $nodes[0]; |
|
111 | + } else { |
|
112 | + return null; |
|
113 | + } |
|
114 | + } |
|
115 | + |
|
116 | + /** |
|
117 | + * @return string the mount point of the mount for the user |
|
118 | + */ |
|
119 | + public function getMountPoint() { |
|
120 | + return $this->mountPoint; |
|
121 | + } |
|
122 | + |
|
123 | + /** |
|
124 | + * Get the id of the configured mount |
|
125 | + * |
|
126 | + * @return int|null mount id or null if not applicable |
|
127 | + * @since 9.1.0 |
|
128 | + */ |
|
129 | + public function getMountId() { |
|
130 | + return $this->mountId; |
|
131 | + } |
|
132 | + |
|
133 | + /** |
|
134 | + * Get the internal path (within the storage) of the root of the mount |
|
135 | + * |
|
136 | + * @return string |
|
137 | + */ |
|
138 | + public function getRootInternalPath() { |
|
139 | + return $this->rootInternalPath; |
|
140 | + } |
|
141 | 141 | } |
@@ -31,25 +31,25 @@ |
||
31 | 31 | * Map a user to a bucket. |
32 | 32 | */ |
33 | 33 | class Mapper { |
34 | - /** @var IUser */ |
|
35 | - private $user; |
|
34 | + /** @var IUser */ |
|
35 | + private $user; |
|
36 | 36 | |
37 | - /** |
|
38 | - * Mapper constructor. |
|
39 | - * |
|
40 | - * @param IUser $user |
|
41 | - */ |
|
42 | - public function __construct(IUser $user) { |
|
43 | - $this->user = $user; |
|
44 | - } |
|
37 | + /** |
|
38 | + * Mapper constructor. |
|
39 | + * |
|
40 | + * @param IUser $user |
|
41 | + */ |
|
42 | + public function __construct(IUser $user) { |
|
43 | + $this->user = $user; |
|
44 | + } |
|
45 | 45 | |
46 | - /** |
|
47 | - * @param int $numBuckets |
|
48 | - * @return string |
|
49 | - */ |
|
50 | - public function getBucket($numBuckets = 64) { |
|
51 | - $hash = md5($this->user->getUID()); |
|
52 | - $num = hexdec(substr($hash, 0, 4)); |
|
53 | - return (string)($num % $numBuckets); |
|
54 | - } |
|
46 | + /** |
|
47 | + * @param int $numBuckets |
|
48 | + * @return string |
|
49 | + */ |
|
50 | + public function getBucket($numBuckets = 64) { |
|
51 | + $hash = md5($this->user->getUID()); |
|
52 | + $num = hexdec(substr($hash, 0, 4)); |
|
53 | + return (string)($num % $numBuckets); |
|
54 | + } |
|
55 | 55 | } |
@@ -50,6 +50,6 @@ |
||
50 | 50 | public function getBucket($numBuckets = 64) { |
51 | 51 | $hash = md5($this->user->getUID()); |
52 | 52 | $num = hexdec(substr($hash, 0, 4)); |
53 | - return (string)($num % $numBuckets); |
|
53 | + return (string) ($num % $numBuckets); |
|
54 | 54 | } |
55 | 55 | } |
@@ -80,7 +80,7 @@ discard block |
||
80 | 80 | // no point in continuing if the section was not found, use original path |
81 | 81 | return $fullPath; |
82 | 82 | } |
83 | - $path = $convertedPath . '/'; |
|
83 | + $path = $convertedPath.'/'; |
|
84 | 84 | } |
85 | 85 | $path = rtrim($path, '/'); |
86 | 86 | return $path; |
@@ -96,7 +96,7 @@ discard block |
||
96 | 96 | * @return string|null original or converted path, or null if none of the forms was found |
97 | 97 | */ |
98 | 98 | private function findPathToUseLastSection($basePath, $lastSection) { |
99 | - $fullPath = $basePath . $lastSection; |
|
99 | + $fullPath = $basePath.$lastSection; |
|
100 | 100 | if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) { |
101 | 101 | $this->namesCache[$fullPath] = $fullPath; |
102 | 102 | return $fullPath; |
@@ -108,7 +108,7 @@ discard block |
||
108 | 108 | } else { |
109 | 109 | $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C); |
110 | 110 | } |
111 | - $otherFullPath = $basePath . $otherFormPath; |
|
111 | + $otherFullPath = $basePath.$otherFormPath; |
|
112 | 112 | if ($this->storage->file_exists($otherFullPath)) { |
113 | 113 | $this->namesCache[$fullPath] = $otherFullPath; |
114 | 114 | return $otherFullPath; |
@@ -40,502 +40,502 @@ |
||
40 | 40 | */ |
41 | 41 | class Encoding extends Wrapper { |
42 | 42 | |
43 | - /** |
|
44 | - * @var ICache |
|
45 | - */ |
|
46 | - private $namesCache; |
|
47 | - |
|
48 | - /** |
|
49 | - * @param array $parameters |
|
50 | - */ |
|
51 | - public function __construct($parameters) { |
|
52 | - $this->storage = $parameters['storage']; |
|
53 | - $this->namesCache = new CappedMemoryCache(); |
|
54 | - } |
|
55 | - |
|
56 | - /** |
|
57 | - * Returns whether the given string is only made of ASCII characters |
|
58 | - * |
|
59 | - * @param string $str string |
|
60 | - * |
|
61 | - * @return bool true if the string is all ASCII, false otherwise |
|
62 | - */ |
|
63 | - private function isAscii($str) { |
|
64 | - return !preg_match('/[\\x80-\\xff]+/', $str); |
|
65 | - } |
|
66 | - |
|
67 | - /** |
|
68 | - * Checks whether the given path exists in NFC or NFD form after checking |
|
69 | - * each form for each path section and returns the correct form. |
|
70 | - * If no existing path found, returns the path as it was given. |
|
71 | - * |
|
72 | - * @param string $fullPath path to check |
|
73 | - * |
|
74 | - * @return string original or converted path |
|
75 | - */ |
|
76 | - private function findPathToUse($fullPath) { |
|
77 | - $cachedPath = $this->namesCache[$fullPath]; |
|
78 | - if ($cachedPath !== null) { |
|
79 | - return $cachedPath; |
|
80 | - } |
|
81 | - |
|
82 | - $sections = explode('/', $fullPath); |
|
83 | - $path = ''; |
|
84 | - foreach ($sections as $section) { |
|
85 | - $convertedPath = $this->findPathToUseLastSection($path, $section); |
|
86 | - if ($convertedPath === null) { |
|
87 | - // no point in continuing if the section was not found, use original path |
|
88 | - return $fullPath; |
|
89 | - } |
|
90 | - $path = $convertedPath . '/'; |
|
91 | - } |
|
92 | - $path = rtrim($path, '/'); |
|
93 | - return $path; |
|
94 | - } |
|
95 | - |
|
96 | - /** |
|
97 | - * Checks whether the last path section of the given path exists in NFC or NFD form |
|
98 | - * and returns the correct form. If no existing path found, returns null. |
|
99 | - * |
|
100 | - * @param string $basePath base path to check |
|
101 | - * @param string $lastSection last section of the path to check for NFD/NFC variations |
|
102 | - * |
|
103 | - * @return string|null original or converted path, or null if none of the forms was found |
|
104 | - */ |
|
105 | - private function findPathToUseLastSection($basePath, $lastSection) { |
|
106 | - $fullPath = $basePath . $lastSection; |
|
107 | - if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) { |
|
108 | - $this->namesCache[$fullPath] = $fullPath; |
|
109 | - return $fullPath; |
|
110 | - } |
|
111 | - |
|
112 | - // swap encoding |
|
113 | - if (\Normalizer::isNormalized($lastSection, \Normalizer::FORM_C)) { |
|
114 | - $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_D); |
|
115 | - } else { |
|
116 | - $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C); |
|
117 | - } |
|
118 | - $otherFullPath = $basePath . $otherFormPath; |
|
119 | - if ($this->storage->file_exists($otherFullPath)) { |
|
120 | - $this->namesCache[$fullPath] = $otherFullPath; |
|
121 | - return $otherFullPath; |
|
122 | - } |
|
123 | - |
|
124 | - // return original path, file did not exist at all |
|
125 | - $this->namesCache[$fullPath] = $fullPath; |
|
126 | - return null; |
|
127 | - } |
|
128 | - |
|
129 | - /** |
|
130 | - * see https://www.php.net/manual/en/function.mkdir.php |
|
131 | - * |
|
132 | - * @param string $path |
|
133 | - * @return bool |
|
134 | - */ |
|
135 | - public function mkdir($path) { |
|
136 | - // note: no conversion here, method should not be called with non-NFC names! |
|
137 | - $result = $this->storage->mkdir($path); |
|
138 | - if ($result) { |
|
139 | - $this->namesCache[$path] = $path; |
|
140 | - } |
|
141 | - return $result; |
|
142 | - } |
|
143 | - |
|
144 | - /** |
|
145 | - * see https://www.php.net/manual/en/function.rmdir.php |
|
146 | - * |
|
147 | - * @param string $path |
|
148 | - * @return bool |
|
149 | - */ |
|
150 | - public function rmdir($path) { |
|
151 | - $result = $this->storage->rmdir($this->findPathToUse($path)); |
|
152 | - if ($result) { |
|
153 | - unset($this->namesCache[$path]); |
|
154 | - } |
|
155 | - return $result; |
|
156 | - } |
|
157 | - |
|
158 | - /** |
|
159 | - * see https://www.php.net/manual/en/function.opendir.php |
|
160 | - * |
|
161 | - * @param string $path |
|
162 | - * @return resource|bool |
|
163 | - */ |
|
164 | - public function opendir($path) { |
|
165 | - return $this->storage->opendir($this->findPathToUse($path)); |
|
166 | - } |
|
167 | - |
|
168 | - /** |
|
169 | - * see https://www.php.net/manual/en/function.is_dir.php |
|
170 | - * |
|
171 | - * @param string $path |
|
172 | - * @return bool |
|
173 | - */ |
|
174 | - public function is_dir($path) { |
|
175 | - return $this->storage->is_dir($this->findPathToUse($path)); |
|
176 | - } |
|
177 | - |
|
178 | - /** |
|
179 | - * see https://www.php.net/manual/en/function.is_file.php |
|
180 | - * |
|
181 | - * @param string $path |
|
182 | - * @return bool |
|
183 | - */ |
|
184 | - public function is_file($path) { |
|
185 | - return $this->storage->is_file($this->findPathToUse($path)); |
|
186 | - } |
|
187 | - |
|
188 | - /** |
|
189 | - * see https://www.php.net/manual/en/function.stat.php |
|
190 | - * only the following keys are required in the result: size and mtime |
|
191 | - * |
|
192 | - * @param string $path |
|
193 | - * @return array|bool |
|
194 | - */ |
|
195 | - public function stat($path) { |
|
196 | - return $this->storage->stat($this->findPathToUse($path)); |
|
197 | - } |
|
198 | - |
|
199 | - /** |
|
200 | - * see https://www.php.net/manual/en/function.filetype.php |
|
201 | - * |
|
202 | - * @param string $path |
|
203 | - * @return string|bool |
|
204 | - */ |
|
205 | - public function filetype($path) { |
|
206 | - return $this->storage->filetype($this->findPathToUse($path)); |
|
207 | - } |
|
208 | - |
|
209 | - /** |
|
210 | - * see https://www.php.net/manual/en/function.filesize.php |
|
211 | - * The result for filesize when called on a folder is required to be 0 |
|
212 | - * |
|
213 | - * @param string $path |
|
214 | - * @return int|bool |
|
215 | - */ |
|
216 | - public function filesize($path) { |
|
217 | - return $this->storage->filesize($this->findPathToUse($path)); |
|
218 | - } |
|
219 | - |
|
220 | - /** |
|
221 | - * check if a file can be created in $path |
|
222 | - * |
|
223 | - * @param string $path |
|
224 | - * @return bool |
|
225 | - */ |
|
226 | - public function isCreatable($path) { |
|
227 | - return $this->storage->isCreatable($this->findPathToUse($path)); |
|
228 | - } |
|
229 | - |
|
230 | - /** |
|
231 | - * check if a file can be read |
|
232 | - * |
|
233 | - * @param string $path |
|
234 | - * @return bool |
|
235 | - */ |
|
236 | - public function isReadable($path) { |
|
237 | - return $this->storage->isReadable($this->findPathToUse($path)); |
|
238 | - } |
|
239 | - |
|
240 | - /** |
|
241 | - * check if a file can be written to |
|
242 | - * |
|
243 | - * @param string $path |
|
244 | - * @return bool |
|
245 | - */ |
|
246 | - public function isUpdatable($path) { |
|
247 | - return $this->storage->isUpdatable($this->findPathToUse($path)); |
|
248 | - } |
|
249 | - |
|
250 | - /** |
|
251 | - * check if a file can be deleted |
|
252 | - * |
|
253 | - * @param string $path |
|
254 | - * @return bool |
|
255 | - */ |
|
256 | - public function isDeletable($path) { |
|
257 | - return $this->storage->isDeletable($this->findPathToUse($path)); |
|
258 | - } |
|
259 | - |
|
260 | - /** |
|
261 | - * check if a file can be shared |
|
262 | - * |
|
263 | - * @param string $path |
|
264 | - * @return bool |
|
265 | - */ |
|
266 | - public function isSharable($path) { |
|
267 | - return $this->storage->isSharable($this->findPathToUse($path)); |
|
268 | - } |
|
269 | - |
|
270 | - /** |
|
271 | - * get the full permissions of a path. |
|
272 | - * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php |
|
273 | - * |
|
274 | - * @param string $path |
|
275 | - * @return int |
|
276 | - */ |
|
277 | - public function getPermissions($path) { |
|
278 | - return $this->storage->getPermissions($this->findPathToUse($path)); |
|
279 | - } |
|
280 | - |
|
281 | - /** |
|
282 | - * see https://www.php.net/manual/en/function.file_exists.php |
|
283 | - * |
|
284 | - * @param string $path |
|
285 | - * @return bool |
|
286 | - */ |
|
287 | - public function file_exists($path) { |
|
288 | - return $this->storage->file_exists($this->findPathToUse($path)); |
|
289 | - } |
|
290 | - |
|
291 | - /** |
|
292 | - * see https://www.php.net/manual/en/function.filemtime.php |
|
293 | - * |
|
294 | - * @param string $path |
|
295 | - * @return int|bool |
|
296 | - */ |
|
297 | - public function filemtime($path) { |
|
298 | - return $this->storage->filemtime($this->findPathToUse($path)); |
|
299 | - } |
|
300 | - |
|
301 | - /** |
|
302 | - * see https://www.php.net/manual/en/function.file_get_contents.php |
|
303 | - * |
|
304 | - * @param string $path |
|
305 | - * @return string|bool |
|
306 | - */ |
|
307 | - public function file_get_contents($path) { |
|
308 | - return $this->storage->file_get_contents($this->findPathToUse($path)); |
|
309 | - } |
|
310 | - |
|
311 | - /** |
|
312 | - * see https://www.php.net/manual/en/function.file_put_contents.php |
|
313 | - * |
|
314 | - * @param string $path |
|
315 | - * @param mixed $data |
|
316 | - * @return int|false |
|
317 | - */ |
|
318 | - public function file_put_contents($path, $data) { |
|
319 | - return $this->storage->file_put_contents($this->findPathToUse($path), $data); |
|
320 | - } |
|
321 | - |
|
322 | - /** |
|
323 | - * see https://www.php.net/manual/en/function.unlink.php |
|
324 | - * |
|
325 | - * @param string $path |
|
326 | - * @return bool |
|
327 | - */ |
|
328 | - public function unlink($path) { |
|
329 | - $result = $this->storage->unlink($this->findPathToUse($path)); |
|
330 | - if ($result) { |
|
331 | - unset($this->namesCache[$path]); |
|
332 | - } |
|
333 | - return $result; |
|
334 | - } |
|
335 | - |
|
336 | - /** |
|
337 | - * see https://www.php.net/manual/en/function.rename.php |
|
338 | - * |
|
339 | - * @param string $path1 |
|
340 | - * @param string $path2 |
|
341 | - * @return bool |
|
342 | - */ |
|
343 | - public function rename($path1, $path2) { |
|
344 | - // second name always NFC |
|
345 | - return $this->storage->rename($this->findPathToUse($path1), $this->findPathToUse($path2)); |
|
346 | - } |
|
347 | - |
|
348 | - /** |
|
349 | - * see https://www.php.net/manual/en/function.copy.php |
|
350 | - * |
|
351 | - * @param string $path1 |
|
352 | - * @param string $path2 |
|
353 | - * @return bool |
|
354 | - */ |
|
355 | - public function copy($path1, $path2) { |
|
356 | - return $this->storage->copy($this->findPathToUse($path1), $this->findPathToUse($path2)); |
|
357 | - } |
|
358 | - |
|
359 | - /** |
|
360 | - * see https://www.php.net/manual/en/function.fopen.php |
|
361 | - * |
|
362 | - * @param string $path |
|
363 | - * @param string $mode |
|
364 | - * @return resource|bool |
|
365 | - */ |
|
366 | - public function fopen($path, $mode) { |
|
367 | - $result = $this->storage->fopen($this->findPathToUse($path), $mode); |
|
368 | - if ($result && $mode !== 'r' && $mode !== 'rb') { |
|
369 | - unset($this->namesCache[$path]); |
|
370 | - } |
|
371 | - return $result; |
|
372 | - } |
|
373 | - |
|
374 | - /** |
|
375 | - * get the mimetype for a file or folder |
|
376 | - * The mimetype for a folder is required to be "httpd/unix-directory" |
|
377 | - * |
|
378 | - * @param string $path |
|
379 | - * @return string|bool |
|
380 | - */ |
|
381 | - public function getMimeType($path) { |
|
382 | - return $this->storage->getMimeType($this->findPathToUse($path)); |
|
383 | - } |
|
384 | - |
|
385 | - /** |
|
386 | - * see https://www.php.net/manual/en/function.hash.php |
|
387 | - * |
|
388 | - * @param string $type |
|
389 | - * @param string $path |
|
390 | - * @param bool $raw |
|
391 | - * @return string|bool |
|
392 | - */ |
|
393 | - public function hash($type, $path, $raw = false) { |
|
394 | - return $this->storage->hash($type, $this->findPathToUse($path), $raw); |
|
395 | - } |
|
396 | - |
|
397 | - /** |
|
398 | - * see https://www.php.net/manual/en/function.free_space.php |
|
399 | - * |
|
400 | - * @param string $path |
|
401 | - * @return int|bool |
|
402 | - */ |
|
403 | - public function free_space($path) { |
|
404 | - return $this->storage->free_space($this->findPathToUse($path)); |
|
405 | - } |
|
406 | - |
|
407 | - /** |
|
408 | - * search for occurrences of $query in file names |
|
409 | - * |
|
410 | - * @param string $query |
|
411 | - * @return array|bool |
|
412 | - */ |
|
413 | - public function search($query) { |
|
414 | - return $this->storage->search($query); |
|
415 | - } |
|
416 | - |
|
417 | - /** |
|
418 | - * see https://www.php.net/manual/en/function.touch.php |
|
419 | - * If the backend does not support the operation, false should be returned |
|
420 | - * |
|
421 | - * @param string $path |
|
422 | - * @param int $mtime |
|
423 | - * @return bool |
|
424 | - */ |
|
425 | - public function touch($path, $mtime = null) { |
|
426 | - return $this->storage->touch($this->findPathToUse($path), $mtime); |
|
427 | - } |
|
428 | - |
|
429 | - /** |
|
430 | - * get the path to a local version of the file. |
|
431 | - * The local version of the file can be temporary and doesn't have to be persistent across requests |
|
432 | - * |
|
433 | - * @param string $path |
|
434 | - * @return string|bool |
|
435 | - */ |
|
436 | - public function getLocalFile($path) { |
|
437 | - return $this->storage->getLocalFile($this->findPathToUse($path)); |
|
438 | - } |
|
439 | - |
|
440 | - /** |
|
441 | - * check if a file or folder has been updated since $time |
|
442 | - * |
|
443 | - * @param string $path |
|
444 | - * @param int $time |
|
445 | - * @return bool |
|
446 | - * |
|
447 | - * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed. |
|
448 | - * returning true for other changes in the folder is optional |
|
449 | - */ |
|
450 | - public function hasUpdated($path, $time) { |
|
451 | - return $this->storage->hasUpdated($this->findPathToUse($path), $time); |
|
452 | - } |
|
453 | - |
|
454 | - /** |
|
455 | - * get a cache instance for the storage |
|
456 | - * |
|
457 | - * @param string $path |
|
458 | - * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache |
|
459 | - * @return \OC\Files\Cache\Cache |
|
460 | - */ |
|
461 | - public function getCache($path = '', $storage = null) { |
|
462 | - if (!$storage) { |
|
463 | - $storage = $this; |
|
464 | - } |
|
465 | - return $this->storage->getCache($this->findPathToUse($path), $storage); |
|
466 | - } |
|
467 | - |
|
468 | - /** |
|
469 | - * get a scanner instance for the storage |
|
470 | - * |
|
471 | - * @param string $path |
|
472 | - * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner |
|
473 | - * @return \OC\Files\Cache\Scanner |
|
474 | - */ |
|
475 | - public function getScanner($path = '', $storage = null) { |
|
476 | - if (!$storage) { |
|
477 | - $storage = $this; |
|
478 | - } |
|
479 | - return $this->storage->getScanner($this->findPathToUse($path), $storage); |
|
480 | - } |
|
481 | - |
|
482 | - /** |
|
483 | - * get the ETag for a file or folder |
|
484 | - * |
|
485 | - * @param string $path |
|
486 | - * @return string|bool |
|
487 | - */ |
|
488 | - public function getETag($path) { |
|
489 | - return $this->storage->getETag($this->findPathToUse($path)); |
|
490 | - } |
|
491 | - |
|
492 | - /** |
|
493 | - * @param IStorage $sourceStorage |
|
494 | - * @param string $sourceInternalPath |
|
495 | - * @param string $targetInternalPath |
|
496 | - * @return bool |
|
497 | - */ |
|
498 | - public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) { |
|
499 | - if ($sourceStorage === $this) { |
|
500 | - return $this->copy($sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
501 | - } |
|
502 | - |
|
503 | - $result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
504 | - if ($result) { |
|
505 | - unset($this->namesCache[$targetInternalPath]); |
|
506 | - } |
|
507 | - return $result; |
|
508 | - } |
|
509 | - |
|
510 | - /** |
|
511 | - * @param IStorage $sourceStorage |
|
512 | - * @param string $sourceInternalPath |
|
513 | - * @param string $targetInternalPath |
|
514 | - * @return bool |
|
515 | - */ |
|
516 | - public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) { |
|
517 | - if ($sourceStorage === $this) { |
|
518 | - $result = $this->rename($sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
519 | - if ($result) { |
|
520 | - unset($this->namesCache[$sourceInternalPath]); |
|
521 | - unset($this->namesCache[$targetInternalPath]); |
|
522 | - } |
|
523 | - return $result; |
|
524 | - } |
|
525 | - |
|
526 | - $result = $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
527 | - if ($result) { |
|
528 | - unset($this->namesCache[$sourceInternalPath]); |
|
529 | - unset($this->namesCache[$targetInternalPath]); |
|
530 | - } |
|
531 | - return $result; |
|
532 | - } |
|
533 | - |
|
534 | - public function getMetaData($path) { |
|
535 | - return $this->storage->getMetaData($this->findPathToUse($path)); |
|
536 | - } |
|
537 | - |
|
538 | - public function getDirectoryContent($directory): \Traversable { |
|
539 | - return $this->storage->getDirectoryContent($this->findPathToUse($directory)); |
|
540 | - } |
|
43 | + /** |
|
44 | + * @var ICache |
|
45 | + */ |
|
46 | + private $namesCache; |
|
47 | + |
|
48 | + /** |
|
49 | + * @param array $parameters |
|
50 | + */ |
|
51 | + public function __construct($parameters) { |
|
52 | + $this->storage = $parameters['storage']; |
|
53 | + $this->namesCache = new CappedMemoryCache(); |
|
54 | + } |
|
55 | + |
|
56 | + /** |
|
57 | + * Returns whether the given string is only made of ASCII characters |
|
58 | + * |
|
59 | + * @param string $str string |
|
60 | + * |
|
61 | + * @return bool true if the string is all ASCII, false otherwise |
|
62 | + */ |
|
63 | + private function isAscii($str) { |
|
64 | + return !preg_match('/[\\x80-\\xff]+/', $str); |
|
65 | + } |
|
66 | + |
|
67 | + /** |
|
68 | + * Checks whether the given path exists in NFC or NFD form after checking |
|
69 | + * each form for each path section and returns the correct form. |
|
70 | + * If no existing path found, returns the path as it was given. |
|
71 | + * |
|
72 | + * @param string $fullPath path to check |
|
73 | + * |
|
74 | + * @return string original or converted path |
|
75 | + */ |
|
76 | + private function findPathToUse($fullPath) { |
|
77 | + $cachedPath = $this->namesCache[$fullPath]; |
|
78 | + if ($cachedPath !== null) { |
|
79 | + return $cachedPath; |
|
80 | + } |
|
81 | + |
|
82 | + $sections = explode('/', $fullPath); |
|
83 | + $path = ''; |
|
84 | + foreach ($sections as $section) { |
|
85 | + $convertedPath = $this->findPathToUseLastSection($path, $section); |
|
86 | + if ($convertedPath === null) { |
|
87 | + // no point in continuing if the section was not found, use original path |
|
88 | + return $fullPath; |
|
89 | + } |
|
90 | + $path = $convertedPath . '/'; |
|
91 | + } |
|
92 | + $path = rtrim($path, '/'); |
|
93 | + return $path; |
|
94 | + } |
|
95 | + |
|
96 | + /** |
|
97 | + * Checks whether the last path section of the given path exists in NFC or NFD form |
|
98 | + * and returns the correct form. If no existing path found, returns null. |
|
99 | + * |
|
100 | + * @param string $basePath base path to check |
|
101 | + * @param string $lastSection last section of the path to check for NFD/NFC variations |
|
102 | + * |
|
103 | + * @return string|null original or converted path, or null if none of the forms was found |
|
104 | + */ |
|
105 | + private function findPathToUseLastSection($basePath, $lastSection) { |
|
106 | + $fullPath = $basePath . $lastSection; |
|
107 | + if ($lastSection === '' || $this->isAscii($lastSection) || $this->storage->file_exists($fullPath)) { |
|
108 | + $this->namesCache[$fullPath] = $fullPath; |
|
109 | + return $fullPath; |
|
110 | + } |
|
111 | + |
|
112 | + // swap encoding |
|
113 | + if (\Normalizer::isNormalized($lastSection, \Normalizer::FORM_C)) { |
|
114 | + $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_D); |
|
115 | + } else { |
|
116 | + $otherFormPath = \Normalizer::normalize($lastSection, \Normalizer::FORM_C); |
|
117 | + } |
|
118 | + $otherFullPath = $basePath . $otherFormPath; |
|
119 | + if ($this->storage->file_exists($otherFullPath)) { |
|
120 | + $this->namesCache[$fullPath] = $otherFullPath; |
|
121 | + return $otherFullPath; |
|
122 | + } |
|
123 | + |
|
124 | + // return original path, file did not exist at all |
|
125 | + $this->namesCache[$fullPath] = $fullPath; |
|
126 | + return null; |
|
127 | + } |
|
128 | + |
|
129 | + /** |
|
130 | + * see https://www.php.net/manual/en/function.mkdir.php |
|
131 | + * |
|
132 | + * @param string $path |
|
133 | + * @return bool |
|
134 | + */ |
|
135 | + public function mkdir($path) { |
|
136 | + // note: no conversion here, method should not be called with non-NFC names! |
|
137 | + $result = $this->storage->mkdir($path); |
|
138 | + if ($result) { |
|
139 | + $this->namesCache[$path] = $path; |
|
140 | + } |
|
141 | + return $result; |
|
142 | + } |
|
143 | + |
|
144 | + /** |
|
145 | + * see https://www.php.net/manual/en/function.rmdir.php |
|
146 | + * |
|
147 | + * @param string $path |
|
148 | + * @return bool |
|
149 | + */ |
|
150 | + public function rmdir($path) { |
|
151 | + $result = $this->storage->rmdir($this->findPathToUse($path)); |
|
152 | + if ($result) { |
|
153 | + unset($this->namesCache[$path]); |
|
154 | + } |
|
155 | + return $result; |
|
156 | + } |
|
157 | + |
|
158 | + /** |
|
159 | + * see https://www.php.net/manual/en/function.opendir.php |
|
160 | + * |
|
161 | + * @param string $path |
|
162 | + * @return resource|bool |
|
163 | + */ |
|
164 | + public function opendir($path) { |
|
165 | + return $this->storage->opendir($this->findPathToUse($path)); |
|
166 | + } |
|
167 | + |
|
168 | + /** |
|
169 | + * see https://www.php.net/manual/en/function.is_dir.php |
|
170 | + * |
|
171 | + * @param string $path |
|
172 | + * @return bool |
|
173 | + */ |
|
174 | + public function is_dir($path) { |
|
175 | + return $this->storage->is_dir($this->findPathToUse($path)); |
|
176 | + } |
|
177 | + |
|
178 | + /** |
|
179 | + * see https://www.php.net/manual/en/function.is_file.php |
|
180 | + * |
|
181 | + * @param string $path |
|
182 | + * @return bool |
|
183 | + */ |
|
184 | + public function is_file($path) { |
|
185 | + return $this->storage->is_file($this->findPathToUse($path)); |
|
186 | + } |
|
187 | + |
|
188 | + /** |
|
189 | + * see https://www.php.net/manual/en/function.stat.php |
|
190 | + * only the following keys are required in the result: size and mtime |
|
191 | + * |
|
192 | + * @param string $path |
|
193 | + * @return array|bool |
|
194 | + */ |
|
195 | + public function stat($path) { |
|
196 | + return $this->storage->stat($this->findPathToUse($path)); |
|
197 | + } |
|
198 | + |
|
199 | + /** |
|
200 | + * see https://www.php.net/manual/en/function.filetype.php |
|
201 | + * |
|
202 | + * @param string $path |
|
203 | + * @return string|bool |
|
204 | + */ |
|
205 | + public function filetype($path) { |
|
206 | + return $this->storage->filetype($this->findPathToUse($path)); |
|
207 | + } |
|
208 | + |
|
209 | + /** |
|
210 | + * see https://www.php.net/manual/en/function.filesize.php |
|
211 | + * The result for filesize when called on a folder is required to be 0 |
|
212 | + * |
|
213 | + * @param string $path |
|
214 | + * @return int|bool |
|
215 | + */ |
|
216 | + public function filesize($path) { |
|
217 | + return $this->storage->filesize($this->findPathToUse($path)); |
|
218 | + } |
|
219 | + |
|
220 | + /** |
|
221 | + * check if a file can be created in $path |
|
222 | + * |
|
223 | + * @param string $path |
|
224 | + * @return bool |
|
225 | + */ |
|
226 | + public function isCreatable($path) { |
|
227 | + return $this->storage->isCreatable($this->findPathToUse($path)); |
|
228 | + } |
|
229 | + |
|
230 | + /** |
|
231 | + * check if a file can be read |
|
232 | + * |
|
233 | + * @param string $path |
|
234 | + * @return bool |
|
235 | + */ |
|
236 | + public function isReadable($path) { |
|
237 | + return $this->storage->isReadable($this->findPathToUse($path)); |
|
238 | + } |
|
239 | + |
|
240 | + /** |
|
241 | + * check if a file can be written to |
|
242 | + * |
|
243 | + * @param string $path |
|
244 | + * @return bool |
|
245 | + */ |
|
246 | + public function isUpdatable($path) { |
|
247 | + return $this->storage->isUpdatable($this->findPathToUse($path)); |
|
248 | + } |
|
249 | + |
|
250 | + /** |
|
251 | + * check if a file can be deleted |
|
252 | + * |
|
253 | + * @param string $path |
|
254 | + * @return bool |
|
255 | + */ |
|
256 | + public function isDeletable($path) { |
|
257 | + return $this->storage->isDeletable($this->findPathToUse($path)); |
|
258 | + } |
|
259 | + |
|
260 | + /** |
|
261 | + * check if a file can be shared |
|
262 | + * |
|
263 | + * @param string $path |
|
264 | + * @return bool |
|
265 | + */ |
|
266 | + public function isSharable($path) { |
|
267 | + return $this->storage->isSharable($this->findPathToUse($path)); |
|
268 | + } |
|
269 | + |
|
270 | + /** |
|
271 | + * get the full permissions of a path. |
|
272 | + * Should return a combination of the PERMISSION_ constants defined in lib/public/constants.php |
|
273 | + * |
|
274 | + * @param string $path |
|
275 | + * @return int |
|
276 | + */ |
|
277 | + public function getPermissions($path) { |
|
278 | + return $this->storage->getPermissions($this->findPathToUse($path)); |
|
279 | + } |
|
280 | + |
|
281 | + /** |
|
282 | + * see https://www.php.net/manual/en/function.file_exists.php |
|
283 | + * |
|
284 | + * @param string $path |
|
285 | + * @return bool |
|
286 | + */ |
|
287 | + public function file_exists($path) { |
|
288 | + return $this->storage->file_exists($this->findPathToUse($path)); |
|
289 | + } |
|
290 | + |
|
291 | + /** |
|
292 | + * see https://www.php.net/manual/en/function.filemtime.php |
|
293 | + * |
|
294 | + * @param string $path |
|
295 | + * @return int|bool |
|
296 | + */ |
|
297 | + public function filemtime($path) { |
|
298 | + return $this->storage->filemtime($this->findPathToUse($path)); |
|
299 | + } |
|
300 | + |
|
301 | + /** |
|
302 | + * see https://www.php.net/manual/en/function.file_get_contents.php |
|
303 | + * |
|
304 | + * @param string $path |
|
305 | + * @return string|bool |
|
306 | + */ |
|
307 | + public function file_get_contents($path) { |
|
308 | + return $this->storage->file_get_contents($this->findPathToUse($path)); |
|
309 | + } |
|
310 | + |
|
311 | + /** |
|
312 | + * see https://www.php.net/manual/en/function.file_put_contents.php |
|
313 | + * |
|
314 | + * @param string $path |
|
315 | + * @param mixed $data |
|
316 | + * @return int|false |
|
317 | + */ |
|
318 | + public function file_put_contents($path, $data) { |
|
319 | + return $this->storage->file_put_contents($this->findPathToUse($path), $data); |
|
320 | + } |
|
321 | + |
|
322 | + /** |
|
323 | + * see https://www.php.net/manual/en/function.unlink.php |
|
324 | + * |
|
325 | + * @param string $path |
|
326 | + * @return bool |
|
327 | + */ |
|
328 | + public function unlink($path) { |
|
329 | + $result = $this->storage->unlink($this->findPathToUse($path)); |
|
330 | + if ($result) { |
|
331 | + unset($this->namesCache[$path]); |
|
332 | + } |
|
333 | + return $result; |
|
334 | + } |
|
335 | + |
|
336 | + /** |
|
337 | + * see https://www.php.net/manual/en/function.rename.php |
|
338 | + * |
|
339 | + * @param string $path1 |
|
340 | + * @param string $path2 |
|
341 | + * @return bool |
|
342 | + */ |
|
343 | + public function rename($path1, $path2) { |
|
344 | + // second name always NFC |
|
345 | + return $this->storage->rename($this->findPathToUse($path1), $this->findPathToUse($path2)); |
|
346 | + } |
|
347 | + |
|
348 | + /** |
|
349 | + * see https://www.php.net/manual/en/function.copy.php |
|
350 | + * |
|
351 | + * @param string $path1 |
|
352 | + * @param string $path2 |
|
353 | + * @return bool |
|
354 | + */ |
|
355 | + public function copy($path1, $path2) { |
|
356 | + return $this->storage->copy($this->findPathToUse($path1), $this->findPathToUse($path2)); |
|
357 | + } |
|
358 | + |
|
359 | + /** |
|
360 | + * see https://www.php.net/manual/en/function.fopen.php |
|
361 | + * |
|
362 | + * @param string $path |
|
363 | + * @param string $mode |
|
364 | + * @return resource|bool |
|
365 | + */ |
|
366 | + public function fopen($path, $mode) { |
|
367 | + $result = $this->storage->fopen($this->findPathToUse($path), $mode); |
|
368 | + if ($result && $mode !== 'r' && $mode !== 'rb') { |
|
369 | + unset($this->namesCache[$path]); |
|
370 | + } |
|
371 | + return $result; |
|
372 | + } |
|
373 | + |
|
374 | + /** |
|
375 | + * get the mimetype for a file or folder |
|
376 | + * The mimetype for a folder is required to be "httpd/unix-directory" |
|
377 | + * |
|
378 | + * @param string $path |
|
379 | + * @return string|bool |
|
380 | + */ |
|
381 | + public function getMimeType($path) { |
|
382 | + return $this->storage->getMimeType($this->findPathToUse($path)); |
|
383 | + } |
|
384 | + |
|
385 | + /** |
|
386 | + * see https://www.php.net/manual/en/function.hash.php |
|
387 | + * |
|
388 | + * @param string $type |
|
389 | + * @param string $path |
|
390 | + * @param bool $raw |
|
391 | + * @return string|bool |
|
392 | + */ |
|
393 | + public function hash($type, $path, $raw = false) { |
|
394 | + return $this->storage->hash($type, $this->findPathToUse($path), $raw); |
|
395 | + } |
|
396 | + |
|
397 | + /** |
|
398 | + * see https://www.php.net/manual/en/function.free_space.php |
|
399 | + * |
|
400 | + * @param string $path |
|
401 | + * @return int|bool |
|
402 | + */ |
|
403 | + public function free_space($path) { |
|
404 | + return $this->storage->free_space($this->findPathToUse($path)); |
|
405 | + } |
|
406 | + |
|
407 | + /** |
|
408 | + * search for occurrences of $query in file names |
|
409 | + * |
|
410 | + * @param string $query |
|
411 | + * @return array|bool |
|
412 | + */ |
|
413 | + public function search($query) { |
|
414 | + return $this->storage->search($query); |
|
415 | + } |
|
416 | + |
|
417 | + /** |
|
418 | + * see https://www.php.net/manual/en/function.touch.php |
|
419 | + * If the backend does not support the operation, false should be returned |
|
420 | + * |
|
421 | + * @param string $path |
|
422 | + * @param int $mtime |
|
423 | + * @return bool |
|
424 | + */ |
|
425 | + public function touch($path, $mtime = null) { |
|
426 | + return $this->storage->touch($this->findPathToUse($path), $mtime); |
|
427 | + } |
|
428 | + |
|
429 | + /** |
|
430 | + * get the path to a local version of the file. |
|
431 | + * The local version of the file can be temporary and doesn't have to be persistent across requests |
|
432 | + * |
|
433 | + * @param string $path |
|
434 | + * @return string|bool |
|
435 | + */ |
|
436 | + public function getLocalFile($path) { |
|
437 | + return $this->storage->getLocalFile($this->findPathToUse($path)); |
|
438 | + } |
|
439 | + |
|
440 | + /** |
|
441 | + * check if a file or folder has been updated since $time |
|
442 | + * |
|
443 | + * @param string $path |
|
444 | + * @param int $time |
|
445 | + * @return bool |
|
446 | + * |
|
447 | + * hasUpdated for folders should return at least true if a file inside the folder is add, removed or renamed. |
|
448 | + * returning true for other changes in the folder is optional |
|
449 | + */ |
|
450 | + public function hasUpdated($path, $time) { |
|
451 | + return $this->storage->hasUpdated($this->findPathToUse($path), $time); |
|
452 | + } |
|
453 | + |
|
454 | + /** |
|
455 | + * get a cache instance for the storage |
|
456 | + * |
|
457 | + * @param string $path |
|
458 | + * @param \OC\Files\Storage\Storage (optional) the storage to pass to the cache |
|
459 | + * @return \OC\Files\Cache\Cache |
|
460 | + */ |
|
461 | + public function getCache($path = '', $storage = null) { |
|
462 | + if (!$storage) { |
|
463 | + $storage = $this; |
|
464 | + } |
|
465 | + return $this->storage->getCache($this->findPathToUse($path), $storage); |
|
466 | + } |
|
467 | + |
|
468 | + /** |
|
469 | + * get a scanner instance for the storage |
|
470 | + * |
|
471 | + * @param string $path |
|
472 | + * @param \OC\Files\Storage\Storage (optional) the storage to pass to the scanner |
|
473 | + * @return \OC\Files\Cache\Scanner |
|
474 | + */ |
|
475 | + public function getScanner($path = '', $storage = null) { |
|
476 | + if (!$storage) { |
|
477 | + $storage = $this; |
|
478 | + } |
|
479 | + return $this->storage->getScanner($this->findPathToUse($path), $storage); |
|
480 | + } |
|
481 | + |
|
482 | + /** |
|
483 | + * get the ETag for a file or folder |
|
484 | + * |
|
485 | + * @param string $path |
|
486 | + * @return string|bool |
|
487 | + */ |
|
488 | + public function getETag($path) { |
|
489 | + return $this->storage->getETag($this->findPathToUse($path)); |
|
490 | + } |
|
491 | + |
|
492 | + /** |
|
493 | + * @param IStorage $sourceStorage |
|
494 | + * @param string $sourceInternalPath |
|
495 | + * @param string $targetInternalPath |
|
496 | + * @return bool |
|
497 | + */ |
|
498 | + public function copyFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) { |
|
499 | + if ($sourceStorage === $this) { |
|
500 | + return $this->copy($sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
501 | + } |
|
502 | + |
|
503 | + $result = $this->storage->copyFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
504 | + if ($result) { |
|
505 | + unset($this->namesCache[$targetInternalPath]); |
|
506 | + } |
|
507 | + return $result; |
|
508 | + } |
|
509 | + |
|
510 | + /** |
|
511 | + * @param IStorage $sourceStorage |
|
512 | + * @param string $sourceInternalPath |
|
513 | + * @param string $targetInternalPath |
|
514 | + * @return bool |
|
515 | + */ |
|
516 | + public function moveFromStorage(IStorage $sourceStorage, $sourceInternalPath, $targetInternalPath) { |
|
517 | + if ($sourceStorage === $this) { |
|
518 | + $result = $this->rename($sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
519 | + if ($result) { |
|
520 | + unset($this->namesCache[$sourceInternalPath]); |
|
521 | + unset($this->namesCache[$targetInternalPath]); |
|
522 | + } |
|
523 | + return $result; |
|
524 | + } |
|
525 | + |
|
526 | + $result = $this->storage->moveFromStorage($sourceStorage, $sourceInternalPath, $this->findPathToUse($targetInternalPath)); |
|
527 | + if ($result) { |
|
528 | + unset($this->namesCache[$sourceInternalPath]); |
|
529 | + unset($this->namesCache[$targetInternalPath]); |
|
530 | + } |
|
531 | + return $result; |
|
532 | + } |
|
533 | + |
|
534 | + public function getMetaData($path) { |
|
535 | + return $this->storage->getMetaData($this->findPathToUse($path)); |
|
536 | + } |
|
537 | + |
|
538 | + public function getDirectoryContent($directory): \Traversable { |
|
539 | + return $this->storage->getDirectoryContent($this->findPathToUse($directory)); |
|
540 | + } |
|
541 | 541 | } |
@@ -37,45 +37,45 @@ |
||
37 | 37 | */ |
38 | 38 | trait LocalTempFileTrait { |
39 | 39 | |
40 | - /** @var string[] */ |
|
41 | - protected $cachedFiles = []; |
|
40 | + /** @var string[] */ |
|
41 | + protected $cachedFiles = []; |
|
42 | 42 | |
43 | - /** |
|
44 | - * @param string $path |
|
45 | - * @return string |
|
46 | - */ |
|
47 | - protected function getCachedFile($path) { |
|
48 | - if (!isset($this->cachedFiles[$path])) { |
|
49 | - $this->cachedFiles[$path] = $this->toTmpFile($path); |
|
50 | - } |
|
51 | - return $this->cachedFiles[$path]; |
|
52 | - } |
|
43 | + /** |
|
44 | + * @param string $path |
|
45 | + * @return string |
|
46 | + */ |
|
47 | + protected function getCachedFile($path) { |
|
48 | + if (!isset($this->cachedFiles[$path])) { |
|
49 | + $this->cachedFiles[$path] = $this->toTmpFile($path); |
|
50 | + } |
|
51 | + return $this->cachedFiles[$path]; |
|
52 | + } |
|
53 | 53 | |
54 | - /** |
|
55 | - * @param string $path |
|
56 | - */ |
|
57 | - protected function removeCachedFile($path) { |
|
58 | - unset($this->cachedFiles[$path]); |
|
59 | - } |
|
54 | + /** |
|
55 | + * @param string $path |
|
56 | + */ |
|
57 | + protected function removeCachedFile($path) { |
|
58 | + unset($this->cachedFiles[$path]); |
|
59 | + } |
|
60 | 60 | |
61 | - /** |
|
62 | - * @param string $path |
|
63 | - * @return string |
|
64 | - */ |
|
65 | - protected function toTmpFile($path) { //no longer in the storage api, still useful here |
|
66 | - $source = $this->fopen($path, 'r'); |
|
67 | - if (!$source) { |
|
68 | - return false; |
|
69 | - } |
|
70 | - if ($pos = strrpos($path, '.')) { |
|
71 | - $extension = substr($path, $pos); |
|
72 | - } else { |
|
73 | - $extension = ''; |
|
74 | - } |
|
75 | - $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension); |
|
76 | - $target = fopen($tmpFile, 'w'); |
|
77 | - \OC_Helper::streamCopy($source, $target); |
|
78 | - fclose($target); |
|
79 | - return $tmpFile; |
|
80 | - } |
|
61 | + /** |
|
62 | + * @param string $path |
|
63 | + * @return string |
|
64 | + */ |
|
65 | + protected function toTmpFile($path) { //no longer in the storage api, still useful here |
|
66 | + $source = $this->fopen($path, 'r'); |
|
67 | + if (!$source) { |
|
68 | + return false; |
|
69 | + } |
|
70 | + if ($pos = strrpos($path, '.')) { |
|
71 | + $extension = substr($path, $pos); |
|
72 | + } else { |
|
73 | + $extension = ''; |
|
74 | + } |
|
75 | + $tmpFile = \OC::$server->getTempManager()->getTemporaryFile($extension); |
|
76 | + $target = fopen($tmpFile, 'w'); |
|
77 | + \OC_Helper::streamCopy($source, $target); |
|
78 | + fclose($target); |
|
79 | + return $tmpFile; |
|
80 | + } |
|
81 | 81 | } |
@@ -29,80 +29,80 @@ |
||
29 | 29 | use OCP\Files\Storage\IStorageFactory; |
30 | 30 | |
31 | 31 | class StorageFactory implements IStorageFactory { |
32 | - /** |
|
33 | - * @var array[] [$name=>['priority'=>$priority, 'wrapper'=>$callable] $storageWrappers |
|
34 | - */ |
|
35 | - private $storageWrappers = []; |
|
32 | + /** |
|
33 | + * @var array[] [$name=>['priority'=>$priority, 'wrapper'=>$callable] $storageWrappers |
|
34 | + */ |
|
35 | + private $storageWrappers = []; |
|
36 | 36 | |
37 | - /** |
|
38 | - * allow modifier storage behaviour by adding wrappers around storages |
|
39 | - * |
|
40 | - * $callback should be a function of type (string $mountPoint, Storage $storage) => Storage |
|
41 | - * |
|
42 | - * @param string $wrapperName name of the wrapper |
|
43 | - * @param callable $callback callback |
|
44 | - * @param int $priority wrappers with the lower priority are applied last (meaning they get called first) |
|
45 | - * @param \OCP\Files\Mount\IMountPoint[] $existingMounts existing mount points to apply the wrapper to |
|
46 | - * @return bool true if the wrapper was added, false if there was already a wrapper with this |
|
47 | - * name registered |
|
48 | - */ |
|
49 | - public function addStorageWrapper($wrapperName, $callback, $priority = 50, $existingMounts = []) { |
|
50 | - if (isset($this->storageWrappers[$wrapperName])) { |
|
51 | - return false; |
|
52 | - } |
|
37 | + /** |
|
38 | + * allow modifier storage behaviour by adding wrappers around storages |
|
39 | + * |
|
40 | + * $callback should be a function of type (string $mountPoint, Storage $storage) => Storage |
|
41 | + * |
|
42 | + * @param string $wrapperName name of the wrapper |
|
43 | + * @param callable $callback callback |
|
44 | + * @param int $priority wrappers with the lower priority are applied last (meaning they get called first) |
|
45 | + * @param \OCP\Files\Mount\IMountPoint[] $existingMounts existing mount points to apply the wrapper to |
|
46 | + * @return bool true if the wrapper was added, false if there was already a wrapper with this |
|
47 | + * name registered |
|
48 | + */ |
|
49 | + public function addStorageWrapper($wrapperName, $callback, $priority = 50, $existingMounts = []) { |
|
50 | + if (isset($this->storageWrappers[$wrapperName])) { |
|
51 | + return false; |
|
52 | + } |
|
53 | 53 | |
54 | - // apply to existing mounts before registering it to prevent applying it double in MountPoint::createStorage |
|
55 | - foreach ($existingMounts as $mount) { |
|
56 | - $mount->wrapStorage($callback); |
|
57 | - } |
|
54 | + // apply to existing mounts before registering it to prevent applying it double in MountPoint::createStorage |
|
55 | + foreach ($existingMounts as $mount) { |
|
56 | + $mount->wrapStorage($callback); |
|
57 | + } |
|
58 | 58 | |
59 | - $this->storageWrappers[$wrapperName] = ['wrapper' => $callback, 'priority' => $priority]; |
|
60 | - return true; |
|
61 | - } |
|
59 | + $this->storageWrappers[$wrapperName] = ['wrapper' => $callback, 'priority' => $priority]; |
|
60 | + return true; |
|
61 | + } |
|
62 | 62 | |
63 | - /** |
|
64 | - * Remove a storage wrapper by name. |
|
65 | - * Note: internal method only to be used for cleanup |
|
66 | - * |
|
67 | - * @param string $wrapperName name of the wrapper |
|
68 | - * @internal |
|
69 | - */ |
|
70 | - public function removeStorageWrapper($wrapperName) { |
|
71 | - unset($this->storageWrappers[$wrapperName]); |
|
72 | - } |
|
63 | + /** |
|
64 | + * Remove a storage wrapper by name. |
|
65 | + * Note: internal method only to be used for cleanup |
|
66 | + * |
|
67 | + * @param string $wrapperName name of the wrapper |
|
68 | + * @internal |
|
69 | + */ |
|
70 | + public function removeStorageWrapper($wrapperName) { |
|
71 | + unset($this->storageWrappers[$wrapperName]); |
|
72 | + } |
|
73 | 73 | |
74 | - /** |
|
75 | - * Create an instance of a storage and apply the registered storage wrappers |
|
76 | - * |
|
77 | - * @param \OCP\Files\Mount\IMountPoint $mountPoint |
|
78 | - * @param string $class |
|
79 | - * @param array $arguments |
|
80 | - * @return \OCP\Files\Storage |
|
81 | - */ |
|
82 | - public function getInstance(IMountPoint $mountPoint, $class, $arguments) { |
|
83 | - return $this->wrap($mountPoint, new $class($arguments)); |
|
84 | - } |
|
74 | + /** |
|
75 | + * Create an instance of a storage and apply the registered storage wrappers |
|
76 | + * |
|
77 | + * @param \OCP\Files\Mount\IMountPoint $mountPoint |
|
78 | + * @param string $class |
|
79 | + * @param array $arguments |
|
80 | + * @return \OCP\Files\Storage |
|
81 | + */ |
|
82 | + public function getInstance(IMountPoint $mountPoint, $class, $arguments) { |
|
83 | + return $this->wrap($mountPoint, new $class($arguments)); |
|
84 | + } |
|
85 | 85 | |
86 | - /** |
|
87 | - * @param \OCP\Files\Mount\IMountPoint $mountPoint |
|
88 | - * @param \OCP\Files\Storage $storage |
|
89 | - * @return \OCP\Files\Storage |
|
90 | - */ |
|
91 | - public function wrap(IMountPoint $mountPoint, $storage) { |
|
92 | - $wrappers = array_values($this->storageWrappers); |
|
93 | - usort($wrappers, function ($a, $b) { |
|
94 | - return $b['priority'] - $a['priority']; |
|
95 | - }); |
|
96 | - /** @var callable[] $wrappers */ |
|
97 | - $wrappers = array_map(function ($wrapper) { |
|
98 | - return $wrapper['wrapper']; |
|
99 | - }, $wrappers); |
|
100 | - foreach ($wrappers as $wrapper) { |
|
101 | - $storage = $wrapper($mountPoint->getMountPoint(), $storage, $mountPoint); |
|
102 | - if (!($storage instanceof \OCP\Files\Storage)) { |
|
103 | - throw new \Exception('Invalid result from storage wrapper'); |
|
104 | - } |
|
105 | - } |
|
106 | - return $storage; |
|
107 | - } |
|
86 | + /** |
|
87 | + * @param \OCP\Files\Mount\IMountPoint $mountPoint |
|
88 | + * @param \OCP\Files\Storage $storage |
|
89 | + * @return \OCP\Files\Storage |
|
90 | + */ |
|
91 | + public function wrap(IMountPoint $mountPoint, $storage) { |
|
92 | + $wrappers = array_values($this->storageWrappers); |
|
93 | + usort($wrappers, function ($a, $b) { |
|
94 | + return $b['priority'] - $a['priority']; |
|
95 | + }); |
|
96 | + /** @var callable[] $wrappers */ |
|
97 | + $wrappers = array_map(function ($wrapper) { |
|
98 | + return $wrapper['wrapper']; |
|
99 | + }, $wrappers); |
|
100 | + foreach ($wrappers as $wrapper) { |
|
101 | + $storage = $wrapper($mountPoint->getMountPoint(), $storage, $mountPoint); |
|
102 | + if (!($storage instanceof \OCP\Files\Storage)) { |
|
103 | + throw new \Exception('Invalid result from storage wrapper'); |
|
104 | + } |
|
105 | + } |
|
106 | + return $storage; |
|
107 | + } |
|
108 | 108 | } |
@@ -90,11 +90,11 @@ |
||
90 | 90 | */ |
91 | 91 | public function wrap(IMountPoint $mountPoint, $storage) { |
92 | 92 | $wrappers = array_values($this->storageWrappers); |
93 | - usort($wrappers, function ($a, $b) { |
|
93 | + usort($wrappers, function($a, $b) { |
|
94 | 94 | return $b['priority'] - $a['priority']; |
95 | 95 | }); |
96 | 96 | /** @var callable[] $wrappers */ |
97 | - $wrappers = array_map(function ($wrapper) { |
|
97 | + $wrappers = array_map(function($wrapper) { |
|
98 | 98 | return $wrapper['wrapper']; |
99 | 99 | }, $wrappers); |
100 | 100 | foreach ($wrappers as $wrapper) { |