/**
* Is the $url in our cache and still valid?
*
* @param string $url URL to check for cache
* @return bool
*/
public function isPageCached($url)
{
$cache_length = trim($this->fetchConfig('cache_length', false));
// if no cache-length is set, this feature is off
if (!(bool) $cache_length) {
return false;
}
if ($this->fetchConfig('ignore_query_strings', false, null, true)) {
$url = $this->removeQueryString($url);
}
// create the hash now so we don't have to do it many times below
$url_hash = Helper::makeHash($url);
// we're no longer allowing `on cache update` here, as its a flawed concept:
// it only appeared to work because new pages were being hit, however, once
// every page is hit and then HTML-cached, the cache will no longer update
// because procedurally, that happens *after* we look for and load a version
// that has been cached
if ($cache_length == 'on cache update' || $cache_length == 'on last modified') {
// ignore the cached version if the last modified time of this URL's
// content file is newer than when the cached version was made
// check that the URL being requested is a content file
$bare_url = strpos($url, '?') !== false ? substr($url, 0, strpos($url, '?')) : $url;
$data = ContentService::getContent($bare_url);
$age = time() - File::getLastModified($data['_file']);
// return if the cache file exists and if it's new enough
return $this->cache->exists($url_hash) && $this->cache->getAge($url_hash) <= $age;
} else {
// purge any cache files older than the cache length
$this->cache->purgeFromBefore('-' . $cache_length);
// return if the file still exists
return $this->cache->exists($url_hash);
}
}
/**
* Checks to see if $file_1 is newer than $file_2
*
* @param string $file File to compare
* @param string $compare_against File to compare against
* @return bool
*/
public static function isNewer($file, $compare_against)
{
return File::getLastModified($file) > File::getLastModified($compare_against);
}
public function index()
{
/*
|--------------------------------------------------------------------------
| Check for image
|--------------------------------------------------------------------------
|
| Transform just needs the path to an image to get started. If it exists,
| the fun begins.
|
*/
$image_src = $this->fetchParam('src', null, false, false, false);
// Set full system path
$image_path = Path::standardize(Path::fromAsset($image_src));
// Check if image exists before doing anything.
if (!File::isImage($image_path)) {
Log::error("Could not find requested image to transform: " . $image_path, "core", "Transform");
return;
}
/*
|--------------------------------------------------------------------------
| Resizing and cropping options
|--------------------------------------------------------------------------
|
| The first transformations we want to run is for size to reduce the
| memory usage for future effects.
|
*/
$width = $this->fetchParam('width', null, 'is_numeric');
$height = $this->fetchParam('height', null, 'is_numeric');
// resize specific
$ratio = $this->fetchParam('ratio', true, false, true);
$upsize = $this->fetchParam('upsize', true, false, true);
// crop specific
$pos_x = $this->fetchParam('pos_x', 0, 'is_numeric');
$pos_y = $this->fetchParam('pos_y', 0, 'is_numeric');
$quality = $this->fetchParam('quality', '75', 'is_numeric');
/*
|--------------------------------------------------------------------------
| Action
|--------------------------------------------------------------------------
|
| Available actions: resize, crop, and guess.
|
| "Guess" will find the best fitting aspect ratio of your given width and
| height on the current image automatically, cut it out and resize it to
| the given dimension.
|
*/
$action = $this->fetchParam('action', 'resize');
/*
|--------------------------------------------------------------------------
| Extra bits
|--------------------------------------------------------------------------
|
| Delicious and probably rarely used options.
|
*/
$angle = $this->fetchParam('rotate', false);
$flip_side = $this->fetchParam('flip', false);
$blur = $this->fetchParam('blur', false, 'is_numeric');
$pixelate = $this->fetchParam('pixelate', false, 'is_numeric');
$greyscale = $this->fetchParam(array('greyscale', 'grayscale'), false, false, true);
/*
|--------------------------------------------------------------------------
| Assemble filename and check for duplicate
|--------------------------------------------------------------------------
|
| We need to make sure we don't already have this image created, so we
| defer any action until we've processed the parameters, which create
| a unique filename.
|
*/
// Late modified time of original image
$last_modified = File::getLastModified($image_path);
// Find .jpg, .png, etc
$extension = File::getExtension($image_path);
// Filename with the extension removed so we can append our unique filename flags
$stripped_image_path = str_replace('.' . $extension, '', $image_path);
// The possible filename flags
$parameter_flags = array('width' => $width, 'height' => $height, 'quality' => $quality, 'rotate' => $angle, 'flip' => $flip_side, 'pos_x' => $pos_x, 'pos_y' => $pos_y, 'blur' => $blur, 'pixelate' => $pixelate, 'greyscale' => $greyscale, 'modified' => $last_modified);
// Start with a 1 character action flag
$file_breadcrumbs = '-' . $action[0];
foreach ($parameter_flags as $param => $value) {
if ($value) {
$flag = is_bool($value) ? '' : $value;
// don't show boolean flags
$file_breadcrumbs .= '-' . $param[0] . $flag;
}
}
// Allow converting filetypes (jpg, png, gif)
$extension = $this->fetchParam('type', $extension);
// Allow saving in a different directory
$destination = $this->fetchParam('destination', Config::get('transform_destination', false), false, false, false);
if ($destination) {
$destination = Path::tidy(BASE_PATH . '/' . $destination);
// Method checks to see if folder exists before creating it
Folder::make($destination);
$stripped_image_path = Path::tidy($destination . '/' . basename($stripped_image_path));
}
// Reassembled filename with all flags filtered and delimited
$new_image_path = $stripped_image_path . $file_breadcrumbs . '.' . $extension;
// Check if we've already built this image before
if (File::exists($new_image_path)) {
return Path::toAsset($new_image_path);
}
/*
|--------------------------------------------------------------------------
| Create Image
|--------------------------------------------------------------------------
|
| Transform just needs the path to an image to get started. The image is
| created in memory so we can start manipulating it.
|
*/
$image = Image::make($image_path);
/*
|--------------------------------------------------------------------------
| Perform Actions
|--------------------------------------------------------------------------
|
| This is fresh transformation. Time to work the magic!
|
*/
if ($action === 'resize' && ($width || $height)) {
$image->resize($width, $height, $ratio, $upsize);
}
if ($action === 'crop' && $width && $height) {
$image->crop($width, $height, $pos_x, $pos_y);
}
if ($action === 'smart') {
$image->grab($width, $height);
}
$resize = $this->fetchParam('resize', null);
if ($resize) {
$resize_options = Helper::explodeOptions($resize, true);
$image->resize(array_get($resize_options, 'width'), array_get($resize_options, 'height'), array_get($resize_options, 'ratio', true), array_get($resize_options, 'upsize', true));
}
$crop = $this->fetchParam('crop', null);
if ($crop) {
$crop_options = Helper::explodeOptions($crop, true);
$image->crop(array_get($crop_options, 'width'), array_get($crop_options, 'height'), array_get($crop_options, 'x'), array_get($crop_options, 'y'));
}
if ($angle) {
$image->rotate($angle);
}
if ($flip_side === 'h' || $flip_side === 'v') {
$image->flip($flip_side);
}
if ($greyscale) {
$image->greyscale();
}
if ($blur) {
$image->blur($blur);
}
if ($pixelate) {
$image->pixelate($pixelate);
}
/*
|--------------------------------------------------------------------------
| Save
|--------------------------------------------------------------------------
|
| Get out of dodge!
|
*/
try {
$image->save($new_image_path, $quality);
} catch (Exception $e) {
Log::fatal('Could not write new images. Try checking your file permissions.', 'core', 'Transform');
throw new Exception('Could not write new images. Try checking your file permissions.');
}
return File::cleanURL($new_image_path);
}
/**
* Gets the age of a given file within this plugin's namespaced storage
*
* @param string $filename Name of file to check
* @return mixed
*/
public function getAge($filename)
{
$this->verifyStorageFolder();
$this->isValidFilename($filename);
$file = $this->contextualize($filename);
return ($this->exists($filename)) ? time() - File::getLastModified($file) : false;
}
/**
* Store the first revision for a given $file
*
* @param string $file The file needing a first revision
*/
public function saveFirstRevision($file)
{
// if this has revisions, abort
if ($this->hasRevisions($file)) {
return;
}
// get file contents
$full_path = Path::assemble(BASE_PATH, Config::getContentRoot(), $file);
$existing_content = File::get($full_path);
// save revision
$this->saveRevision($file, $existing_content, __('first_save'), File::getLastModified($full_path));
}
/**
* Get time when this folder, subfolders or files was last modified.
* @return time the folder and its content was last modified.
*/
function getLastModified()
{
if (!empty($this->id)) {
global $dbi;
// Get last modified for this folder
$lastModified = "";
$result = $dbi->query("SELECT UNIX_TIMESTAMP(lastUpdated) FROM " . logTableName . " WHERE type='folder' AND typeId='" . $this->id . "'");
if ($result->rows()) {
list($lastModified) = $result->fetchrow_array();
}
// Check if folders inside the folder have been modified
$result = $dbi->query("SELECT id FROM " . folderTableName . " WHERE parentId=" . $dbi->quote($this->id));
for ($i = 0; list($id) = $result->fetchrow_array(); $i++) {
$folder = new Folder($id);
if ($folder->getLastModified() > $lastModified) {
$lastModified = $folder->getLastModified();
}
}
// Check if files inside the folder have been modified
$result = $dbi->query("SELECT id FROM " . fileTableName . " WHERE folderId=" . $dbi->quote($this->id));
for ($i = 0; list($id) = $result->fetchrow_array(); $i++) {
$file = new File($id);
if ($file->getLastModified() > $lastModified) {
$lastModified = $file->getLastModified();
}
}
// Return time the folder was last modified
if (!empty($lastModified)) {
return $lastModified;
}
}
return mktime();
}
/**
* Gets the age of a given file within this plugin's namespaced cache
*
* @param string $filename Name of file to check
* @return mixed
*/
public function getAge($filename)
{
$this->isValidFilename($filename);
$file = $this->contextualize($filename);
return $this->exists($filename) ? time() - File::getLastModified($file) : false;
}
<td nowrap="nowrap" align="right" class="small1 <?php
echo $class;
?>
">
<?php
$site->printFormattedSize($file->getSize());
?>
</td>
<td nowrap="nowrap" class="small1 <?php
echo $class;
?>
">
<?php
$lastModified = $file->getLastModified();
if ($lastModified != 0) {
$site->printTimestamp($lastModified);
} else {
echo "-";
}
?>
</td>
<td height="25" class="item<?php
echo $i % 2 == 0 ? "Alt" : "";
?>
">
<?php
echo $login->isAdmin() ? "<a href=\"" . scriptUrl . "/" . folderAdmin . "/" . folderFiles . "/" . fileFilesEditFile . "?fileId=" . $file->id . "\"><img src=\"" . iconUrl . "/edit.png\" border=\"0\" /></a>" : "";
?>
/**
* Updates the internal content cache
*
* @return boolean
*/
public static function update()
{
// start measuring
$content_hash = Debug::markStart('caching', 'content');
// track if any files have changed
$files_changed = false;
$settings_changed = false;
$members_changed = false;
// grab length of content type extension
$content_type = Config::getContentType();
$full_content_root = rtrim(Path::tidy(BASE_PATH . "/" . Config::getContentRoot()), "/");
$content_type_length = strlen($content_type) + 1;
// the cache files we'll use
$cache_file = BASE_PATH . '/_cache/_app/content/content.php';
$settings_file = BASE_PATH . '/_cache/_app/content/settings.php';
$structure_file = BASE_PATH . '/_cache/_app/content/structure.php';
$time_file = BASE_PATH . '/_cache/_app/content/last.php';
$members_file = BASE_PATH . '/_cache/_app/members/members.php';
$now = time();
// start measuring settings hash
$settings_hash = Debug::markStart('caching', 'settings');
// check for current and new settings
$settings = unserialize(File::get($settings_file));
if (!is_array($settings)) {
$settings = array('site_root' => '', 'site_url' => '', 'timezone' => '', 'date_format' => '', 'time_format' => '', 'content_type' => '', 'taxonomy' => '', 'taxonomy_case_sensitive' => '', 'taxonomy_force_lowercase' => '', 'entry_timestamps' => '', 'base_path' => '', 'app_version' => '');
}
// look up current settings
$current_settings = array('site_root' => Config::getSiteRoot(), 'site_url' => Config::getSiteURL(), 'timezone' => Config::get('timezone'), 'date_format' => Config::get('date_format'), 'time_format' => Config::get('time_format'), 'content_type' => Config::get('content_type'), 'taxonomy' => Config::getTaxonomies(), 'taxonomy_case_sensitive' => Config::getTaxonomyCaseSensitive(), 'taxonomy_force_lowercase' => Config::getTaxonomyForceLowercase(), 'entry_timestamps' => Config::getEntryTimestamps(), 'base_path' => BASE_PATH, 'app_version' => STATAMIC_VERSION);
// have cache-altering settings changed?
if ($settings !== $current_settings) {
// settings have changed
$settings_changed = true;
// clear the cache and set current settings
$cache = self::getCleanCacheArray();
$settings = $current_settings;
$last = null;
} else {
// grab the existing cache
$cache = unserialize(File::get($cache_file));
if (!is_array($cache)) {
$cache = self::getCleanCacheArray();
}
$last = File::get($time_file);
}
// mark end of settings hash measuring
Debug::markEnd($settings_hash);
// grab a list of all content files
$files = File::globRecursively(Path::tidy(BASE_PATH . '/' . Config::getContentRoot() . '/*'), Config::getContentType());
// grab a separate list of files that have changed since last check
$updated = array();
$current_files = array();
// loop through files, getting local paths and checking for updated files
foreach ($files as $file) {
$local_file = Path::trimFilesystemFromContent(Path::standardize($file));
// add to current files
$current_files[] = $local_file;
// is this updated?
if ($last && File::getLastModified($file) >= $last) {
$updated[] = $local_file;
}
}
// get a diff of files we know about and files currently existing
$known_files = array();
foreach ($cache['urls'] as $url_data) {
array_push($known_files, $url_data['path']);
}
$new_files = array_diff($current_files, $known_files);
// create a master list of files that need updating
$changed_files = array_unique(array_merge($new_files, $updated));
// store a list of changed URLs
$changed_urls = array();
// add to the cache if files have been updated
if (count($changed_files)) {
$files_changed = true;
// build content cache
foreach ($changed_files as $file) {
$file = $full_content_root . $file;
$local_path = Path::trimFilesystemFromContent($file);
// before cleaning anything, check for hidden or draft content
$is_hidden = Path::isHidden($local_path);
$is_draft = Path::isDraft($local_path);
// now clean up the path
$local_filename = Path::clean($local_path);
// file parsing
$content = substr(File::get($file), 3);
$divide = strpos($content, "\n---");
$front_matter = trim(substr($content, 0, $divide));
$content_raw = trim(substr($content, $divide + 4));
// parse data
$data = YAML::parse($front_matter);
if ($content_raw) {
$data['content'] = 'true';
$data['content_raw'] = 'true';
}
// set additional information
$data['_file'] = $file;
$data['_local_path'] = $local_path;
$data['_order_key'] = null;
$data['datetimestamp'] = null;
// legacy
$data['datestamp'] = null;
$data['date'] = null;
$data['time'] = null;
$data['numeric'] = null;
$data['last_modified'] = filemtime($file);
$data['_is_hidden'] = $is_hidden;
$data['_is_draft'] = $is_draft;
// get initial slug (may be changed below)
$data['slug'] = ltrim(basename($file, "." . $content_type), "_");
// folder
$instance = $data['slug'] == 'page' ? 1 : 0;
$data['_folder'] = Path::clean($data['_local_path']);
$slash = Helper::strrpos_count($data['_folder'], '/', $instance);
$data['_folder'] = !$slash ? '' : substr($data['_folder'], 1, $slash - 1);
$data['_folder'] = !strlen($data['_folder']) ? "/" : $data['_folder'];
$data['_basename'] = $data['slug'] . '.' . $content_type;
$data['_filename'] = $data['slug'];
$data['_is_entry'] = preg_match(Pattern::ENTRY_FILEPATH, $data['_basename']);
$data['_is_page'] = preg_match(Pattern::PAGE_FILEPATH, $data['_basename']);
// 404 is special
if ($data['_local_path'] === "/404.{$content_type}") {
$local_filename = $local_path;
// order key: date or datetime
} elseif (preg_match(Pattern::DATE_OR_DATETIME, $data['_basename'], $matches)) {
// order key: date or datetime
$date = $matches[1] . '-' . $matches[2] . '-' . $matches[3];
$time = null;
if (Config::getEntryTimestamps() && isset($matches[4])) {
$time = substr($matches[4], 0, 2) . ":" . substr($matches[4], 2);
$date = $date . " " . $time;
$data['slug'] = substr($data['slug'], 16);
$data['datetimestamp'] = $data['_order_key'];
} else {
$data['slug'] = substr($data['slug'], 11);
}
$data['_order_key'] = strtotime($date);
$data['datestamp'] = $data['_order_key'];
$data['date'] = Date::format(Config::getDateFormat(), $data['_order_key']);
$data['time'] = $time ? Date::format(Config::getTimeFormat(), $data['_order_key']) : null;
// order key: slug is page, back up a level
} elseif ($data['slug'] == 'page' && preg_match(Pattern::NUMERIC, substr($data['_local_path'], Helper::strrpos_count($data['_local_path'], '/', 1)), $matches)) {
// order key: slug is page, back up a level
$data['_order_key'] = $matches[1];
$data['numeric'] = $data['_order_key'];
// order key: numeric
} elseif (preg_match(Pattern::NUMERIC, $data['_basename'], $matches)) {
// order key: numeric
$data['_order_key'] = $matches[1];
$data['numeric'] = $data['_order_key'];
$data['slug'] = substr($data['slug'], strlen($matches[1]) + 1);
// order key: other
} else {
// order key: other
$data['_order_key'] = $data['_basename'];
}
// determine url
$data['url'] = preg_replace('#/__?#', '/', $local_filename);
// remove any content type extensions from the end of filename
if (substr($data['url'], -$content_type_length) === '.' . $content_type) {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - $content_type_length);
}
// remove any base pages from filename
if (substr($data['url'], -5) == '/page') {
$data['url'] = substr($data['url'], 0, strlen($data['url']) - 5);
}
// add the site root
$data['url'] = Path::tidy(Config::getSiteRoot() . $data['url']);
// add the site URL to get the permalink
$data['permalink'] = Path::tidy(Config::getSiteURL() . $data['url']);
// new content
if (!isset($cache['content'][$data['_folder']]) || !is_array($cache['content'][$data['_folder']])) {
$cache['content'][$data['_folder']] = array();
}
$slug_with_extension = $data['_filename'] == 'page' ? substr($data['url'], strrpos($data['url'], '/') + 1) . '/' . $data['_filename'] . "." . $content_type : $data['_filename'] . "." . $content_type;
$cache['content'][$data['_folder']][$slug_with_extension] = array('folder' => $data['_folder'], 'path' => $local_path, 'file' => $slug_with_extension, 'url' => $data['url'], 'data' => $data);
$cache['urls'][$data['url']] = array('folder' => $data['_folder'], 'path' => $local_path, 'file' => $slug_with_extension);
$changed_urls[$data['url']] = true;
}
}
// loop through all cached content for deleted files
// this isn't as expensive as you'd think in real-world situations
foreach ($cache['content'] as $folder => $folder_contents) {
foreach ($folder_contents as $path => $data) {
if (File::exists($full_content_root . $data['path'])) {
// still here, keep it
continue;
}
$files_changed = true;
// get URL
$url = isset($cache['content'][$folder][$path]['url']) ? $cache['content'][$folder][$path]['url'] : null;
// only remove from URLs list if not in changed URLs list
if (!isset($changed_urls[$url]) && !is_null($url)) {
// remove from url cache
unset($cache['urls'][$url]);
}
// remove from content cache
unset($cache['content'][$folder][$path]);
}
}
// build taxonomy cache
// only happens if files were added, updated, or deleted above
if ($files_changed) {
$taxonomies = Config::getTaxonomies();
$force_lowercase = Config::getTaxonomyForceLowercase();
$case_sensitive = Config::getTaxonomyCaseSensitive();
$cache['taxonomies'] = array();
// rebuild taxonomies
if (count($taxonomies)) {
// set up taxonomy array
foreach ($taxonomies as $taxonomy) {
$cache['taxonomies'][$taxonomy] = array();
}
// loop through content to build cached array
foreach ($cache['content'] as $pages) {
foreach ($pages as $item) {
$data = $item['data'];
// loop through the types of taxonomies
foreach ($taxonomies as $taxonomy) {
// if this file contains this type of taxonomy
if (isset($data[$taxonomy])) {
$values = Helper::ensureArray($data[$taxonomy]);
// add the file name to the list of found files for a given taxonomy value
foreach ($values as $value) {
if (!$value) {
continue;
}
$key = !$case_sensitive ? strtolower($value) : $value;
if (!isset($cache['taxonomies'][$taxonomy][$key])) {
$cache['taxonomies'][$taxonomy][$key] = array('name' => $force_lowercase ? strtolower($value) : $value, 'files' => array());
}
array_push($cache['taxonomies'][$taxonomy][$key]['files'], $data['url']);
}
}
}
}
}
}
// build structure cache
$structure = array();
$home = Path::tidy('/' . Config::getSiteRoot() . '/');
foreach ($cache['content'] as $pages) {
foreach ($pages as $item) {
// set up base variables
$parent = null;
// Trim off home and any /page.md ending so that all URLs are treated
// equally regardless of page type.
$order_key = str_replace('/page.md', '', str_replace($home, '', $item['path']));
$sub_order_key = $item['data']['_order_key'];
// does this have a parent (and if so, what is it?)
if ($item['url'] !== $home) {
$parent = $home;
$depth = substr_count(str_replace($home, '/', $item['url']), '/');
$last_slash = strrpos($item['url'], '/', 1);
$last_order_slash = strrpos($order_key, '/', 0);
if ($last_slash !== false) {
$parent = substr($item['url'], 0, $last_slash);
}
if ($last_order_slash !== false) {
$order_key = substr($order_key, 0, $last_order_slash);
}
if ($item['data']['_is_page']) {
$type = $item['data']['slug'] == 'page' ? 'folder' : 'page';
} else {
$type = 'entry';
}
} else {
$depth = 0;
$type = 'folder';
$order_key = $home;
}
$structure[$item['url']] = array('parent' => $parent, 'is_entry' => $item['data']['_is_entry'], 'is_page' => $item['data']['_is_page'], 'is_hidden' => $item['data']['_is_hidden'], 'is_draft' => $item['data']['_is_draft'], 'depth' => $depth, 'order_key' => $order_key ? $order_key : $sub_order_key, 'sub_order_key' => $sub_order_key, 'type' => $type);
}
}
}
// mark ending of content cache measuring
Debug::markEnd($content_hash);
if (!Config::get('disable_member_cache')) {
// build member cache
// ----------------------------------------------------------------
// start measuring
$member_hash = Debug::markStart('caching', 'member');
// grab a list of existing members
$users = File::globRecursively(Path::tidy(Config::getConfigPath() . '/users/*'), 'yaml');
// clone for reuse, set up our list of updated users
$updated = array();
$current_users = array();
foreach ($users as $user) {
$local_file = Path::trimFilesystemFromContent(Path::standardize($user));
// add to current users
$current_users[] = $local_file;
// is this updated?
if ($last && File::getLastModified($user) >= $last) {
$updated[] = $local_file;
}
}
// get users from the file
$members = unserialize(File::get($members_file));
// get a diff of users we know about and files currently existing
$known_users = array();
if (!empty($members)) {
foreach ($members as $username => $member_data) {
$known_users[$username] = $member_data['_path'];
}
}
// create a master list of users that need updating
$changed_users = array_unique(array_merge(array_diff($current_users, $known_users), $updated));
$removed_users = array_diff($known_users, $current_users);
if (count($changed_users)) {
$members_changed = true;
foreach ($changed_users as $user_file) {
// file parsing
$last_slash = strrpos($user_file, '/') + 1;
$last_dot = strrpos($user_file, '.');
$username = substr($user_file, $last_slash, $last_dot - $last_slash);
$content = substr(File::get($user_file), 3);
$divide = strpos($content, "\n---");
$data = YAML::parse(trim(substr($content, 0, $divide)));
$bio_raw = trim(substr($content, $divide + 4));
$data['_path'] = $user_file;
if ($bio_raw) {
$data['biography'] = 'true';
$data['biography_raw'] = 'true';
}
$members[$username] = $data;
}
}
// loop through all cached content for deleted files
// this isn't as expensive as you'd think in real-world situations
if (!empty($removed_users)) {
$members_changed = true;
$members = array_diff_key($members, $removed_users);
}
// mark ending of member cache measuring
Debug::markEnd($member_hash);
}
// write to caches
// --------------------------------------------------------------------
// add file-writing to content-cache actions
$content_hash = Debug::markStart('caching', 'content');
if ($files_changed) {
// store the content cache
if (File::put($cache_file, serialize($cache)) === false) {
if (!File::isWritable($cache_file)) {
Log::fatal('Cache folder is not writable.', 'core', 'content-cache');
}
Log::fatal('Could not write to the cache.', 'core', 'content-cache');
return false;
}
// store the structure cache
if (File::put($structure_file, serialize($structure)) === false) {
if (!File::isWritable($structure_file)) {
Log::fatal('Structure cache file is not writable.', 'core', 'structure-cache');
}
Log::fatal('Could not write to the structure cache.', 'core', 'structure-cache');
return false;
}
}
// mark ending of content cache file write measuring
Debug::markEnd($content_hash);
// add file-writing to settings-cache actions
$settings_hash = Debug::markStart('caching', 'settings');
// store the settings cache
if ($settings_changed) {
if (File::put($settings_file, serialize($settings)) === false) {
if (!File::isWritable($settings_file)) {
Log::fatal('Settings cache file is not writable.', 'core', 'settings-cache');
}
Log::fatal('Could not write to the settings cache file.', 'core', 'settings-cache');
return false;
}
}
// mark ending of settings cache file write measuring
Debug::markEnd($settings_hash);
if (!Config::get('disable_member_cache')) {
// add file-writing to settings-cache actions
$member_hash = Debug::markStart('caching', 'member');
// store the members cache
if ($members_changed) {
if (File::put($members_file, serialize($members)) === false) {
if (!File::isWritable($members_file)) {
Log::fatal('Member cache file is not writable.', 'core', 'member-cache');
}
Log::fatal('Could not write to the member cache file.', 'core', 'member-cache');
return false;
}
}
// mark ending of member cache file write measuring
Debug::markEnd($member_hash);
}
File::put($time_file, $now - 1);
return true;
}
