563 lines
15 KiB
PHP
563 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* The filesystem library of zentaopms.
|
|
*
|
|
* @copyright Copyright 2009-2023 禅道软件（青岛）有限公司(ZenTao Software (Qingdao) Co., Ltd. www.zentao.net)
|
|
* @license ZPL(https://zpl.pub/page/zplv12.html) or AGPL(https://www.gnu.org/licenses/agpl-3.0.en.html)
|
|
* @author Lu Fei <lufei@easycorp.ltd>
|
|
* @package cache
|
|
* @link https://www.zentao.net
|
|
*/
|
|
|
|
/**
|
|
* Most of the methods in this file come from illuminate/filesystem,
|
|
* thanks Laravel Team provide such a useful class.
|
|
*/
|
|
class filesystem
|
|
{
|
|
/**
|
|
* Determine if a file or directory exists.
|
|
*/
|
|
public function exists(string $path): bool
|
|
{
|
|
return file_exists($path);
|
|
}
|
|
|
|
/**
|
|
* Get the contents of a file.
|
|
*
|
|
* @throws RuntimeException
|
|
*/
|
|
public function get(string $path, bool $lock = false): string
|
|
{
|
|
if ($this->isFile($path)) {
|
|
return $lock ? $this->sharedGet($path) : file_get_contents($path);
|
|
}
|
|
|
|
throw new RuntimeException("File does not exist at path {$path}");
|
|
}
|
|
|
|
/**
|
|
* Get contents of a file with shared access.
|
|
*/
|
|
public function sharedGet(string $path): string
|
|
{
|
|
return $this->atomic($path, function ($path) {
|
|
$contents = '';
|
|
$handle = fopen($path, 'rb');
|
|
if ($handle) {
|
|
$wouldBlock = false;
|
|
flock($handle, LOCK_SH | LOCK_NB, $wouldBlock);
|
|
while ($wouldBlock) {
|
|
usleep(1000);
|
|
flock($handle, LOCK_SH | LOCK_NB, $wouldBlock);
|
|
}
|
|
try {
|
|
clearstatcache(true, $path);
|
|
$contents = fread($handle, $this->size($path) ?: 1);
|
|
} finally {
|
|
flock($handle, LOCK_UN);
|
|
fclose($handle);
|
|
}
|
|
}
|
|
return $contents;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get the returned value of a file.
|
|
*
|
|
* @throws RuntimeException
|
|
*/
|
|
public function getRequire(string $path)
|
|
{
|
|
if ($this->isFile($path)) {
|
|
return require $path;
|
|
}
|
|
|
|
throw new RuntimeException("File does not exist at path {$path}");
|
|
}
|
|
|
|
/**
|
|
* Require the given file once.
|
|
*/
|
|
public function requireOnce(string $file): void
|
|
{
|
|
require_once $file;
|
|
}
|
|
|
|
/**
|
|
* Get the MD5 hash of the file at the given path.
|
|
*/
|
|
public function hash(string $path): string
|
|
{
|
|
return md5_file($path);
|
|
}
|
|
|
|
/**
|
|
* Clears file status cache.
|
|
*/
|
|
public function clearStatCache(string $path): void
|
|
{
|
|
clearstatcache(true, $path);
|
|
}
|
|
|
|
/**
|
|
* Write the contents of a file.
|
|
*
|
|
* @param resource|string $contents
|
|
* @return bool|int
|
|
*/
|
|
public function put(string $path, $contents, bool $lock = false)
|
|
{
|
|
if ($lock) {
|
|
return $this->atomic($path, function ($path) use ($contents) {
|
|
$handle = fopen($path, 'w+');
|
|
if ($handle) {
|
|
$wouldBlock = false;
|
|
flock($handle, LOCK_EX | LOCK_NB, $wouldBlock);
|
|
while ($wouldBlock) {
|
|
usleep(1000);
|
|
flock($handle, LOCK_EX | LOCK_NB, $wouldBlock);
|
|
}
|
|
try {
|
|
fwrite($handle, $contents);
|
|
} finally {
|
|
flock($handle, LOCK_UN);
|
|
fclose($handle);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return file_put_contents($path, $contents);
|
|
}
|
|
|
|
/**
|
|
* Write the contents of a file, replacing it atomically if it already exists.
|
|
*/
|
|
public function replace(string $path, string $content)
|
|
{
|
|
// If the path already exists and is a symlink, get the real path...
|
|
clearstatcache(true, $path);
|
|
|
|
$path = realpath($path) ?: $path;
|
|
|
|
$tempPath = tempnam(dirname($path), basename($path));
|
|
|
|
// Fix permissions of tempPath because `tempnam()` creates it with permissions set to 0600...
|
|
chmod($tempPath, 0777 - umask());
|
|
|
|
file_put_contents($tempPath, $content);
|
|
|
|
rename($tempPath, $path);
|
|
}
|
|
|
|
/**
|
|
* Prepend to a file.
|
|
*/
|
|
public function prepend(string $path, string $data): int
|
|
{
|
|
if ($this->exists($path)) {
|
|
return $this->put($path, $data . $this->get($path));
|
|
}
|
|
|
|
return $this->put($path, $data);
|
|
}
|
|
|
|
/**
|
|
* Append to a file.
|
|
*/
|
|
public function append(string $path, string $data): int
|
|
{
|
|
return file_put_contents($path, $data, FILE_APPEND);
|
|
}
|
|
|
|
/**
|
|
* Get or set UNIX mode of a file or directory.
|
|
*/
|
|
public function chmod(string $path, ?int $mode = null)
|
|
{
|
|
if ($mode) {
|
|
return chmod($path, $mode);
|
|
}
|
|
|
|
return substr(sprintf('%o', fileperms($path)), -4);
|
|
}
|
|
|
|
/**
|
|
* Delete the file at a given path.
|
|
*
|
|
* @param array|string $paths
|
|
*/
|
|
public function delete($paths): bool
|
|
{
|
|
$paths = is_array($paths) ? $paths : func_get_args();
|
|
|
|
$success = true;
|
|
|
|
foreach ($paths as $path) {
|
|
try {
|
|
if (! @unlink($path)) {
|
|
$success = false;
|
|
}
|
|
} catch (ErrorException $e) {
|
|
$success = false;
|
|
}
|
|
}
|
|
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Move a file to a new location.
|
|
*/
|
|
public function move(string $path, string $target): bool
|
|
{
|
|
return rename($path, $target);
|
|
}
|
|
|
|
/**
|
|
* Copy a file to a new location.
|
|
*/
|
|
public function copy(string $path, string $target): bool
|
|
{
|
|
return copy($path, $target);
|
|
}
|
|
|
|
/**
|
|
* Create a hard link to the target file or directory.
|
|
*/
|
|
public function link(string $target, string $link): bool
|
|
{
|
|
if (! $this->windowsOs()) {
|
|
return symlink($target, $link);
|
|
}
|
|
|
|
$mode = $this->isDirectory($target) ? 'J' : 'H';
|
|
|
|
exec("mklink /{$mode} \"{$link}\" \"{$target}\"");
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Extract the file name from a file path.
|
|
*/
|
|
public function name(string $path): string
|
|
{
|
|
return pathinfo($path, PATHINFO_FILENAME);
|
|
}
|
|
|
|
/**
|
|
* Extract the trailing name component from a file path.
|
|
*/
|
|
public function basename(string $path): string
|
|
{
|
|
return pathinfo($path, PATHINFO_BASENAME);
|
|
}
|
|
|
|
/**
|
|
* Extract the parent directory from a file path.
|
|
*/
|
|
public function dirname(string $path): string
|
|
{
|
|
return pathinfo($path, PATHINFO_DIRNAME);
|
|
}
|
|
|
|
/**
|
|
* Extract the file extension from a file path.
|
|
*/
|
|
public function extension(string $path): string
|
|
{
|
|
return pathinfo($path, PATHINFO_EXTENSION);
|
|
}
|
|
|
|
/**
|
|
* Get the file type of a given file.
|
|
*/
|
|
public function type(string $path): string
|
|
{
|
|
return filetype($path);
|
|
}
|
|
|
|
/**
|
|
* Get the mime-type of a given file.
|
|
*
|
|
* @return false|string
|
|
*/
|
|
public function mimeType(string $path)
|
|
{
|
|
return finfo_file(finfo_open(FILEINFO_MIME_TYPE), $path);
|
|
}
|
|
|
|
/**
|
|
* Get the file size of a given file.
|
|
*/
|
|
public function size(string $path): int
|
|
{
|
|
return filesize($path);
|
|
}
|
|
|
|
/**
|
|
* Get the file's last modification time.
|
|
*/
|
|
public function lastModified(string $path): int
|
|
{
|
|
return filemtime($path);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given path is a directory.
|
|
*/
|
|
public function isDirectory(string $directory): bool
|
|
{
|
|
return is_dir($directory);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given path is readable.
|
|
*/
|
|
public function isReadable(string $path): bool
|
|
{
|
|
return is_readable($path);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given path is writable.
|
|
*/
|
|
public function isWritable(string $path): bool
|
|
{
|
|
return is_writable($path);
|
|
}
|
|
|
|
/**
|
|
* Determine if the given path is a file.
|
|
*/
|
|
public function isFile(string $file): bool
|
|
{
|
|
return is_file($file);
|
|
}
|
|
|
|
/**
|
|
* Find path names matching a given pattern.
|
|
*/
|
|
public function glob(string $pattern, int $flags = 0): array
|
|
{
|
|
return glob($pattern, $flags);
|
|
}
|
|
|
|
/**
|
|
* Get an array of all files in a directory.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function files(string $directory, bool $hidden = false): array
|
|
{
|
|
$files = array();
|
|
$iterator = new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS);
|
|
$filter = new RecursiveCallbackFilterIterator($iterator, function ($fileInfo) use ($hidden) {
|
|
if (! $hidden && $fileInfo->getFilename()[0] === '.') {
|
|
return false;
|
|
}
|
|
return $fileInfo->isFile();
|
|
});
|
|
foreach (new RecursiveIteratorIterator($filter) as $fileInfo) {
|
|
$files[] = $fileInfo;
|
|
}
|
|
return $files;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get all of the files from the given directory (recursive).
|
|
* @return array
|
|
*/
|
|
public function allFiles(string $directory, bool $hidden = false): array
|
|
{
|
|
$directory = rtrim($directory, '/\\');
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS),
|
|
RecursiveIteratorIterator::LEAVES_ONLY
|
|
);
|
|
$files = array();
|
|
|
|
foreach ($iterator as $file) {
|
|
if (! $hidden && $file->getFilename()[0] == '.') {
|
|
continue;
|
|
}
|
|
$files[] = new \SplFileInfo($file->getPathname());
|
|
}
|
|
|
|
return $files;
|
|
}
|
|
|
|
/**
|
|
* Get all of the directories within a given directory.
|
|
*/
|
|
public function directories(string $directory): array
|
|
{
|
|
$directory = rtrim($directory, '/\\');
|
|
$directories = array();
|
|
|
|
$iterator = new RecursiveIteratorIterator(
|
|
new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS),
|
|
RecursiveIteratorIterator::SELF_FIRST,
|
|
RecursiveIteratorIterator::CATCH_GET_CHILD
|
|
);
|
|
|
|
foreach ($iterator as $path => $dir) {
|
|
if ($dir->isDir() && !$dir->isLink()) {
|
|
$directories[] = $path;
|
|
}
|
|
}
|
|
|
|
sort($directories);
|
|
|
|
return $directories;
|
|
}
|
|
|
|
/**
|
|
* Create a directory.
|
|
*/
|
|
public function makeDirectory(string $path, int $mode = 0755, bool $recursive = false, bool $force = false): bool
|
|
{
|
|
if ($force) {
|
|
return @mkdir($path, $mode, $recursive);
|
|
}
|
|
|
|
return mkdir($path, $mode, $recursive);
|
|
}
|
|
|
|
/**
|
|
* Move a directory.
|
|
*/
|
|
public function moveDirectory(string $from, string $to, bool $overwrite = false): bool
|
|
{
|
|
if ($overwrite && $this->isDirectory($to) && ! $this->deleteDirectory($to)) {
|
|
return false;
|
|
}
|
|
|
|
return @rename($from, $to) === true;
|
|
}
|
|
|
|
/**
|
|
* Copy a directory from one location to another.
|
|
*/
|
|
public function copyDirectory(string $directory, string $destination, int $options = null): bool
|
|
{
|
|
if (! $this->isDirectory($directory)) {
|
|
return false;
|
|
}
|
|
|
|
$options = $options ?: FilesystemIterator::SKIP_DOTS;
|
|
|
|
// If the destination directory does not actually exist, we will go ahead and
|
|
// create it recursively, which just gets the destination prepared to copy
|
|
// the files over. Once we make the directory we'll proceed the copying.
|
|
if (! $this->isDirectory($destination)) {
|
|
$this->makeDirectory($destination, 0777, true);
|
|
}
|
|
|
|
$items = new FilesystemIterator($directory, $options);
|
|
|
|
foreach ($items as $item) {
|
|
// As we spin through items, we will check to see if the current file is actually
|
|
// a directory or a file. When it is actually a directory we will need to call
|
|
// back into this function recursively to keep copying these nested folders.
|
|
$target = $destination . DIRECTORY_SEPARATOR . $item->getBasename();
|
|
|
|
if ($item->isDir()) {
|
|
$path = $item->getPathname();
|
|
|
|
if (! $this->copyDirectory($path, $target, $options)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If the current items is just a regular file, we will just copy this to the new
|
|
// location and keep looping. If for some reason the copy fails we'll bail out
|
|
// and return false, so the developer is aware that the copy process failed.
|
|
else {
|
|
if (! $this->copy($item->getPathname(), $target)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Recursively delete a directory.
|
|
*
|
|
* The directory itself may be optionally preserved.
|
|
*/
|
|
public function deleteDirectory(string $directory, bool $preserve = false): bool
|
|
{
|
|
if (! $this->isDirectory($directory)) {
|
|
return false;
|
|
}
|
|
|
|
$items = new FilesystemIterator($directory);
|
|
|
|
foreach ($items as $item) {
|
|
// If the item is a directory, we can just recurse into the function and
|
|
// delete that sub-directory otherwise we'll just delete the file and
|
|
// keep iterating through each file until the directory is cleaned.
|
|
if ($item->isDir() && ! $item->isLink()) {
|
|
$this->deleteDirectory($item->getPathname());
|
|
}
|
|
|
|
// If the item is just a file, we can go ahead and delete it since we're
|
|
// just looping through and waxing all of the files in this directory
|
|
// and calling directories recursively, so we delete the real path.
|
|
else {
|
|
$this->delete($item->getPathname());
|
|
}
|
|
}
|
|
|
|
if (! $preserve) {
|
|
@rmdir($directory);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove all of the directories within a given directory.
|
|
*/
|
|
public function deleteDirectories(string $directory): bool
|
|
{
|
|
$allDirectories = $this->directories($directory);
|
|
|
|
if (! empty($allDirectories)) {
|
|
foreach ($allDirectories as $directoryName) {
|
|
$this->deleteDirectory($directoryName);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Empty the specified directory of all files and folders.
|
|
*/
|
|
public function cleanDirectory(string $directory): bool
|
|
{
|
|
return $this->deleteDirectory($directory, true);
|
|
}
|
|
|
|
/**
|
|
* Detect whether it's Windows.
|
|
*/
|
|
public function windowsOs(): bool
|
|
{
|
|
return stripos(PHP_OS, 'win') === 0;
|
|
}
|
|
|
|
protected function atomic($path, $callback)
|
|
{
|
|
return $callback($path);
|
|
}
|
|
} |