Fs.php

Go to the documentation of this file.

<?php
 
namespace Depage\Fs;
 
class Fs
{
    protected $currentPath;
    protected $base;
    protected $url;
    protected $hidden;
    protected $streamContextOptions = array();
    protected $streamContext;
    protected $path;
    protected $errorHandlerDepth = 0;
    public function __construct($params = array())
    {
        if (isset($params['scheme']))   $this->url['scheme']    = $params['scheme'];
        if (isset($params['user']))     $this->url['user']      = $params['user'];
        if (isset($params['pass']))     $this->url['pass']      = $params['pass'];
        if (isset($params['host']))     $this->url['host']      = $params['host'];
        if (isset($params['port']))     $this->url['port']      = $params['port'];
 
        $this->hidden   = (isset($params['hidden']))    ? $params['hidden'] : false;
        $this->path     = (isset($params['path']))      ? $params['path']   : '.';
 
        $this->streamContext = stream_context_create($this->streamContextOptions);
    }
    public static function factory($url, $params = array())
    {
        $parsed = self::parseUrl($url);
        if (is_array($parsed)) {
            $params = array_merge($parsed, $params);
        }
        $scheme = $params['scheme'] ?? '';
        $alias = self::schemeAlias($scheme);
 
        $schemeClass = '\Depage\Fs\Fs' . ucfirst($alias['class']);
        $params['scheme'] = $alias['scheme'];
 
        return new $schemeClass($params);
    }
    protected static function schemeAlias($alias = '')
    {
        // null would be deprecated as an array key in php 8.5
        $alias = (string) $alias;
 
        $aliases = array(
            ''          => array('class' => 'file', 'scheme' => 'file'),
            'file'      => array('class' => 'file', 'scheme' => 'file'),
            'ftp'       => array('class' => 'ftp',  'scheme' => 'ftp'),
            'ftps'      => array('class' => 'ftp',  'scheme' => 'ftps'),
            'ssh2.sftp' => array('class' => 'ssh',  'scheme' => 'ssh2.sftp'),
            'ssh'       => array('class' => 'ssh',  'scheme' => 'ssh2.sftp'),
            'sftp'      => array('class' => 'ssh',  'scheme' => 'ssh2.sftp'),
        );
 
        if (array_key_exists($alias, $aliases)) {
            $translation = $aliases[$alias];
        } else {
            $translation = array('class' => '', 'scheme' => $alias);
        }
 
        return $translation;
    }
 
    public function pwd()
    {
        $this->preCommandHook();
 
        try {
            $url = $this->url;
            $url['path'] = $this->base . $this->currentPath;
            $pwd = $this->buildUrl($url);
 
            return $pwd;
        } finally {
            $this->postCommandHook();
        }
    }
    public function ls($url)
    {
        $this->preCommandHook();
 
        try {
            $cleanUrl = $this->cleanUrl($url);
            $path = str_replace($this->pwd(), '', $cleanUrl);
            $ls = $this->lsRecursive($path, '');
 
            return $ls;
        } finally {
            $this->postCommandHook();
        }
    }
    public function lsDir($path = '')
    {
        $this->preCommandHook();
 
        try {
            $lsDir = $this->lsFilter($path, 'is_dir');
 
            return $lsDir;
        } finally {
            $this->postCommandHook();
        }
    }
    public function lsFiles($path = '')
    {
        $this->preCommandHook();
 
        try {
            $lsFiles = $this->lsFilter($path, 'is_file');
 
            return $lsFiles;
        } finally {
            $this->postCommandHook();
        }
    }
    public function exists($remotePath)
    {
        $this->preCommandHook();
 
        try {
            $remote = $this->cleanUrl($remotePath);
            $exists = file_exists($remote);
 
            return $exists;
        } finally {
            $this->postCommandHook();
        }
    }
    public function fileInfo($remotePath)
    {
        $this->preCommandHook();
 
        try {
            $remote = $this->cleanUrl($remotePath);
            $fileInfo = new \SplFileInfo($remote);
 
            return $fileInfo;
        } finally {
            $this->postCommandHook();
        }
    }
 
    public function cd($url)
    {
        $this->preCommandHook();
 
        try {
            $cleanUrl = $this->cleanUrl($url);
 
            if (is_dir($cleanUrl) && is_readable($cleanUrl . '/.')) {
                $this->currentPath = str_replace($this->pwd(), '', $cleanUrl) . '/';
            } else {
                throw new Exceptions\FsException('Directory not accessible "' . $this->cleanUrl($url, false) . '".');
            }
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function mkdir($pathName, $mode = 0777, $recursive = true)
    {
        $this->preCommandHook();
 
        try {
            $cleanUrl = $this->cleanUrl($pathName);
            if (!is_dir($cleanUrl)) {
                $success = mkdir($cleanUrl, $mode, $recursive, $this->streamContext);
 
                if (!$success && !is_dir($cleanUrl)) {
                    throw new Exceptions\FsException('Error while creating directory "' . $pathName . '".');
                }
            }
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function rm($url)
    {
        $this->preCommandHook();
 
        try {
            $cleanUrl = $this->cleanUrl($url);
            $pwd = $this->pwd();
 
            if (preg_match('/^' . preg_quote($cleanUrl, '/') . '\//', $pwd . '/')) {
                throw new Exceptions\FsException('Cannot delete current or parent directory "' . $this->cleanUrl($pwd, false) . '".');
            }
            $this->rmRecursive($cleanUrl);
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function copy($sourcePath, $targetPath)
    {
        $this->preCommandHook();
 
        try {
            $source = $this->cleanUrl($sourcePath);
            $target = $this->cleanUrl($targetPath);
 
            if (file_exists($source)) {
                if(file_exists($target) && is_dir($target)) {
                    $target .= '/' . $this->extractFileName($source);
                }
                \copy($source, $target, $this->streamContext);
            } else {
                throw new Exceptions\FsException('Cannot copy "' . $this->cleanUrl($sourcePath, false) . '" to "' . $this->cleanUrl($targetPath, false) . '" - source doesn\'t exist.');
            }
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function mv($sourcePath, $targetPath)
    {
        $this->preCommandHook();
 
        try {
            $source = $this->cleanUrl($sourcePath);
            $target = $this->cleanUrl($targetPath);
 
            if (file_exists($source)) {
                if(file_exists($target) && is_dir($target)) {
                    $target .= '/' . $this->extractFileName($source);
                }
                $this->rename($source, $target);
            } else {
                throw new Exceptions\FsException('Cannot move "' . $this->cleanUrl($sourcePath, false) . '" to "' . $this->cleanUrl($targetPath, false) . '" - source doesn\'t exist.');
            }
 
        } finally {
            $this->postCommandHook();
        }
    }
 
    public function get($remotePath, $local = null)
    {
        $this->preCommandHook();
 
        try {
            if ($local === null) {
                $local = $this->extractFileName($remotePath);
            }
 
            $remote = $this->cleanUrl($remotePath);
            copy($remote, $local, $this->streamContext);
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function put($local, $remotePath)
    {
        $this->preCommandHook();
 
        try {
            $remote = $this->cleanUrl($remotePath);
            copy($local, $remote, $this->streamContext);
 
        } finally {
            $this->postCommandHook();
        }
    }
    public function getString($remotePath)
    {
        $this->preCommandHook();
 
        try {
            $remote = $this->cleanUrl($remotePath);
            $string = file_get_contents($remote, false, $this->streamContext);
 
            return $string;
        } finally {
            $this->postCommandHook();
        }
    }
    public function putString($remotePath, $string)
    {
        $this->preCommandHook();
 
        try {
            $remote = $this->cleanUrl($remotePath);
            $this->file_put_contents($remote, $string, 0, $this->streamContext);
 
        } finally {
            $this->postCommandHook();
        }
    }
 
    public function test(&$error = null)
    {
        $testFile = 'depage-fs-test-file.tmp';
        $testString = 'depage-fs-test-string';
        $success = false;
 
        try {
            if (!$this->exists($testFile)) {
                $this->putString($testFile, $testString);
                if ($this->getString($testFile) === $testString) {
                    $this->rm($testFile);
                    $success = !$this->exists($testFile);
                }
            }
        } catch (Exceptions\FsException $exception) {
            $error = $exception->getMessage();
        }
 
        return $success;
    }
 
    protected function preCommandHook()
    {
        $this->lateConnect();
        $this->setErrorHandler(true);
    }
    protected function postCommandHook()
    {
        $this->setErrorHandler(false);
    }
    protected function lateConnect()
    {
        if (!isset($this->base)) {
            $this->setBase($this->path);
        }
    }
    protected function setBase($path)
    {
        $cleanPath = $this->cleanPath('/' . $path);
        $this->base = (substr($cleanPath, -1) == '/') ? $cleanPath : $cleanPath . '/';
    }
 
    public function depageFsErrorHandler($errno, $errstr, $errfile, $errline)
    {
        if ($this->errorHandlerDepth > 0) {
            $this->errorHandlerDepth = 0;
            restore_error_handler();
        }
        throw new Exceptions\FsException($errstr);
    }
    protected function setErrorHandler($start)
    {
        if ($start) {
            if ($this->errorHandlerDepth++ === 0) {
                set_error_handler(array($this, 'depageFsErrorHandler'));
            }
        } elseif ($this->errorHandlerDepth > 0 && --$this->errorHandlerDepth === 0) {
            restore_error_handler();
        }
    }
 
    public static function parseUrl($url)
    {
        $parsed = parse_url($url);
 
        // hack, parse_url (PHP 5.6.29) won't handle resource name strings
        if (isset($parsed['fragment'])) {
            $urlParts = explode('/', $url);
 
            if (isset($urlParts[2]) && preg_match('/^Resource id \#([0-9]+)$/', $urlParts[2], $matches)) {
                $urlParts[2] = $matches[1];
                $parsed = parse_url(implode('/', $urlParts));
                $parsed['host'] = 'Resource id #' . $parsed['host'];
            }
        }
 
        // hack, parse_url matches anything after the first question mark as "query"
        $path = (isset($parsed['path'])) ? $parsed['path'] : '';
        $query = (isset($parsed['query'])) ? $parsed['query'] : '';
        if (!empty($query) || preg_match('/\?$/', $url)) {
            $parsed['path'] = $path . '?' . $query;
            unset($parsed['query']);
        }
 
        return $parsed;
    }
    protected function cleanUrl($url, $showPass = true)
    {
        $parsed = self::parseUrl($url);
        $scheme = (isset($parsed['scheme'])) ? $parsed['scheme'] : null;
        $path = (isset($parsed['path'])) ? $parsed['path'] : null;
 
        if ($scheme) {
            $newUrl = $parsed;
            $newPath = $path;
        } else {
            $newUrl = $this->url;
            if (substr($url, 0, 1) == '/') {
                $newPath = $url;
            } else {
                $newPath = $this->base . $this->currentPath;
                $newPath .= (substr($path, 0, 1) == '/') ? '' : '/';
                $newPath .= $path;
            }
        }
 
        $newUrl['path'] = $this->cleanPath($newPath);
 
        if (!preg_match(';^' . preg_quote($this->cleanPath($this->base)) . '(.*)$;',  $newUrl['path'])) {
            throw new Exceptions\FsException('Cannot leave base directory "' . $this->base . '".');
        }
 
        return $this->buildUrl($newUrl, $showPass);
    }
    protected function cleanPath($path)
    {
        $dirs = explode('/', $path);
        $newDirs = array();
 
        foreach ($dirs as $dir) {
            if ($dir == '..') {
                array_pop($newDirs);
            } elseif ($dir != '.' && $dir != '') {
                $newDirs[] = $dir;
            }
        }
 
        $newPath = (substr($path, 0, 1) == '/') ? '/' : '';
        $newPath .= implode('/', $newDirs);
 
        return $newPath;
    }
    protected function buildUrl($parsed, $showPass = true)
    {
        $path = $parsed['scheme'] . '://';
        $path .= !empty($parsed['user']) ? rawurlencode($parsed['user']) : '';
 
        if (!empty($parsed['pass'])) {
            $path .= ($showPass) ? ':' . rawurlencode($parsed['pass']) : ':...';
        }
 
        $path .= !empty($parsed['user']) ? '@'                   : '';
        $path .= !empty($parsed['host']) ? $parsed['host']       : '';
        $path .= !empty($parsed['port']) ? ':' . $parsed['port'] : '';
        $path .= !empty($parsed['path']) ? $parsed['path']       : '/';
 
        return $path;
    }
    protected function extractFileName($path)
    {
        $pathInfo = pathinfo($path);
        $fileName = $pathInfo['filename'];
 
        if (isset($pathInfo['extension'])) {
            $fileName .= '.' . $pathInfo['extension'];
        }
 
        return $fileName;
    }
 
    protected function lsFilter($path, $function)
    {
        $ls = $this->ls($path);
        $pwd = $this->pwd();
        $lsFiltered = array_filter(
            $ls,
            function ($element) use ($function, $pwd) {
                return $function($pwd . $element);
            }
        );
        natcasesort($lsFiltered);
        $sorted = array_values($lsFiltered);
 
        return $sorted;
    }
    protected function matchNodesInPath($path, $pattern)
    {
        if (preg_match('/[' . preg_quote('*?[]') . ']/', $pattern)) {
            $matches = array_filter(
                $this->scandir($path),
                function ($node) use ($pattern) { return fnmatch($pattern, $node); }
            );
        } else {
            $matches = array($pattern);
        }
        return $matches;
    }
    protected function lsRecursive($path, $current)
    {
        $nodes = array();
        $patterns = explode('/', $path);
        $count = count($patterns);
        $pwd = $this->pwd();
 
        if ($count) {
            $pattern = array_shift($patterns);
            $matches = $this->matchNodesInPath($pwd . $current, $pattern);
 
            foreach ($matches as $match) {
                $next = ($current) ? $current . '/' . $match : $match;
 
                if ($count === 1) {
                    $nodes[] = $next;
                } elseif (is_dir($pwd . $next)) {
                    $nodes = array_merge(
                        $nodes,
                        $this->lsRecursive(implode('/', $patterns), $next)
                    );
                }
            }
        }
 
        return $nodes;
    }
    protected function rmRecursive($cleanUrl)
    {
        if (!file_exists($cleanUrl)) {
            throw new Exceptions\FsException('"' . $this->cleanUrl($cleanUrl, false) . '" doesn\'t exist.');
        } elseif (is_dir($cleanUrl)) {
            foreach ($this->scandir($cleanUrl, true) as $nested) {
                $this->rmRecursive($cleanUrl . '/' .  $nested);
            }
            $this->rmdir($cleanUrl);
        } elseif (is_file($cleanUrl)) {
            unlink($cleanUrl, $this->streamContext);
        }
 
        clearstatcache(true, $cleanUrl);
    }
 
    protected function scandir($cleanUrl = '', $hidden = null)
    {
        if ($hidden === null) {
            $hidden = $this->hidden;
        }
 
        $scanDir = \scandir($cleanUrl, 0, $this->streamContext);
        $filtered = array_diff($scanDir, array('.', '..'));
 
        if (!$hidden) {
            $filtered = array_filter(
                $filtered,
                function ($node) { return ($node[0] != '.'); }
            );
        }
 
        natcasesort($filtered);
        $sorted = array_values($filtered);
 
        return $sorted;
    }

    protected function rmdir($url)
    {
        return \rmdir($url, $this->streamContext);
    }

    protected function rename($source, $target)
    {
        return \rename($source, $target, $this->streamContext);
    }

    public function file_put_contents($filename, $data, $flags = 0, $context = null)
    {
        return \file_put_contents($filename, $data, $flags, $context);
    }
}
 
/* vim:set ft=php sw=4 sts=4 fdm=marker : */