SimpleCache.php

Go to the documentation of this file.

<?php
 
namespace Elgg\Cache;
 
use Elgg\Config;
use Elgg\Project\Paths;
use Elgg\ViewsService;
 
class SimpleCache {
    
    protected array $simplecache_views = [];
 
    public function __construct(
        protected Config $config,
        protected ViewsService $views
    ) {
    }
 
    public function getUrl(string $view): string {
        $this->registerCacheableView($view);
 
        return $this->getRoot() . $view;
    }
 
    public function getRoot(): string {
        $viewtype = $this->views->getViewtype();
        if ($this->isEnabled()) {
            $lastcache = (int) $this->config->lastcache;
        } else {
            $lastcache = 0;
        }
 
        return elgg_normalize_url("/cache/{$lastcache}/{$viewtype}/");
    }
    
    public function registerCacheableView(string $view): void {
        $this->simplecache_views[$view] = true;
    }
    
    public function isCacheableView(string $view): bool {
        if (isset($this->simplecache_views[$view])) {
            return true;
        }
        
        // build list of viewtypes to check
        $current_viewtype = $this->views->getViewtype();
        $viewtypes = [$current_viewtype];
        
        if ($this->views->doesViewtypeFallback($current_viewtype) && $current_viewtype != 'default') {
            $viewtypes[] = 'default';
        }
        
        // If a static view file is found in any viewtype, it's considered cacheable
        foreach ($viewtypes as $viewtype) {
            $file = $this->views->findViewFile($view, $viewtype);
            
            if ($file && pathinfo($file, PATHINFO_EXTENSION) !== 'php') {
                $this->simplecache_views[$view] = true;
                
                return true;
            }
        }
        
        // Assume not-cacheable by default
        return false;
    }
    
    public function getCacheableViews(): array {
        return $this->simplecache_views;
    }
 
    public function isEnabled(): bool {
        return (bool) $this->config->simplecache_enabled;
    }
 
    public function enable(): void {
        $this->config->save('simplecache_enabled', 1);
    }
 
    public function disable(): void {
        if (!$this->isEnabled()) {
            return;
        }
        
        $this->config->save('simplecache_enabled', 0);
    }
 
    protected function getPath(): string {
        return (string) $this->config->assetroot;
    }
    
    public function clear(): void {
        elgg_delete_directory($this->getPath(), true);
    }
    
    public function purge(): void {
        $lastcache = (int) $this->config->lastcache;
        
        if (!is_dir($this->getPath())) {
            return;
        }
        
        $di = new \DirectoryIterator($this->getPath());
        
        /* @var $file_info \DirectoryIterator */
        foreach ($di as $file_info) {
            if (!$file_info->isDir() || $file_info->isDot()) {
                continue;
            }
            
            if ((int) $file_info->getBasename() === $lastcache) {
                continue;
            }
            
            elgg_delete_directory($file_info->getPathname());
        }
    }
    
    public function cachedAssetExists(int $cache_time, string $viewtype, string $view): bool {
        $filename = $this->getCacheFilename($viewtype, $view, $cache_time);
        
        return file_exists($filename);
    }
    
    public function getCachedAssetLocation(int $cache_time, string $viewtype, string $view): ?string {
        if (!$this->cachedAssetExists($cache_time, $viewtype, $view)) {
            return null;
        }
        
        return $this->getCacheFilename($viewtype, $view, $cache_time);
    }
    
    public function cacheAsset(string $viewtype, string $view, string $contents): int {
        $filename = $this->getCacheFilename($viewtype, $view);
        $dir = dirname($filename);
        
        if (!is_dir($dir)) {
            // PHP and the server accessing the cache symlink may be a different user. And here
            // it's safe to make everything readable anyway.
            mkdir($dir, 0775, true);
        }
        
        $result = file_put_contents($filename, $contents);
        chmod($filename, 0664);
        
        return $result;
    }
    
    protected function getCacheFilename(string $viewtype, string $view, ?int $cache_time = null): string {
        if (!isset($cache_time)) {
            $cache_time = $this->config->lastcache;
        }
        
        $filename = $this->getPath() . "{$cache_time}/{$viewtype}/{$view}";
        return Paths::sanitize($filename, false);
    }
    
    public function isSymbolicLinked(): bool {
        $simplecache_path = rtrim($this->getPath(), '/');
        $symlink_path = elgg_get_root_path() . 'cache';
        
        return is_dir($symlink_path) && realpath($simplecache_path) === realpath($symlink_path);
    }
    
    public function createSymbolicLink(): bool {
        if ($this->isSymbolicLinked()) {
            // symlink exists, no need to proceed
            return true;
        }
        
        $symlink_path = Paths::project() . 'cache';
        if (is_dir($symlink_path)) {
            // Cache directory already exists
            // We can not proceed without overwriting files
            return false;
        }
        
        $simplecache_path = rtrim($this->getPath(), '/');
        if (!is_dir($simplecache_path)) {
            // Views simplecache directory has not yet been created
            mkdir($simplecache_path, 0755, true);
        }
        
        symlink($simplecache_path, $symlink_path);
        
        if ($this->isSymbolicLinked()) {
            return true;
        }
        
        if (is_dir($symlink_path)) {
            unlink($symlink_path);
        }
        
        return false;
    }
}