/**
* checks permissions of all required filesystem resources.
*
* @return array An array of error messages
*/
public static function checkFilesystem()
{
// -------------------------- SCHREIBRECHTE
$writables = [rex_path::media(), rex_path::assets(), rex_path::cache(), rex_path::data(), rex_path::src()];
$func = function ($dir) use(&$func) {
if (!rex_dir::isWritable($dir)) {
return ['setup_304' => [$dir]];
}
$res = [];
foreach (rex_finder::factory($dir) as $path => $file) {
if ($file->isDir()) {
$res = array_merge_recursive($res, $func($path));
} elseif (!$file->isWritable()) {
$res['setup_305'][] = $path;
}
}
return $res;
};
$res = [];
foreach ($writables as $dir) {
if (@is_dir($dir)) {
$res = array_merge_recursive($res, $func($dir));
} else {
$res['setup_306'][] = $dir;
}
}
return $res;
}
public function addTestFolder($folder)
{
if (is_dir($folder)) {
rex_autoload::addDirectory($folder);
$this->testFoldersIterator->append(rex_finder::factory($folder)->recursive()->filesOnly()->getIterator());
}
}
public static function copyDirToArchive($dir, $archive, $basename = null, $excludeDirs = null)
{
$dir = rtrim($dir, '/\\');
$basename = $basename ?: basename($dir);
rex_dir::create(dirname($archive));
$files = array();
$iterator = rex_finder::factory($dir)->recursive()->filesOnly();
if ($excludeDirs) {
$iterator->ignoreDirs($excludeDirs, false);
}
foreach ($iterator as $path => $file) {
$subpath = str_replace($dir, $basename, $path);
$subpath = str_replace('\\', '/', $subpath);
$files[$subpath] = $path;
}
if (class_exists('ZipArchive')) {
$zip = new ZipArchive();
$zip->open($archive, ZipArchive::CREATE);
foreach ($files as $path => $realpath) {
$zip->addFile($realpath, $path);
}
$zip->close();
} else {
$phar = new PharData($archive, 0, null, Phar::ZIP);
$phar->buildFromIterator(new ArrayIterator($files));
$phar->compressFiles(Phar::GZ);
foreach ($files as $path => $realpath) {
if (filesize($realpath) == 0) {
$phar[$path]->decompress();
}
}
}
}
/**
* Deletes the cache.
*
* @package redaxo\core
*/
function rex_delete_cache()
{
// close logger, so the logfile can also be deleted
rex_logger::close();
$finder = rex_finder::factory(rex_path::cache())->recursive()->childFirst()->ignoreFiles(['.htaccess', '.redaxo'], false)->ignoreSystemStuff(false);
rex_dir::deleteIterator($finder);
rex_clang::reset();
// ----- EXTENSION POINT
return rex_extension::registerPoint(new rex_extension_point('CACHE_DELETED', rex_i18n::msg('delete_cache_message')));
}
private function addDir(ZipArchive $zip, $dir, $base)
{
$dir = rtrim($dir, '\\/');
$finder = rex_finder::factory($dir)->recursive()->filesOnly();
/** @var SplFileInfo $file */
foreach ($finder as $path => $file) {
if (!$this->shouldIgnore($path)) {
$zip->addFile($path, $base . substr($path, strlen($dir)));
}
}
}
public static function getBackupFiles($filePrefix)
{
$dir = self::getDir();
$folder = rex_finder::factory($dir)->filesOnly();
$filtered = [];
foreach ($folder as $file) {
$file = $file->getFilename();
if (substr($file, strlen($file) - strlen($filePrefix)) == $filePrefix) {
$filtered[] = $file;
}
}
$folder = $filtered;
usort($folder, function ($file_a, $file_b) use($dir) {
$time_a = filemtime($dir . '/' . $file_a);
$time_b = filemtime($dir . '/' . $file_b);
if ($time_a == $time_b) {
return 0;
}
return $time_a > $time_b ? -1 : 1;
});
return $folder;
}
public function execute()
{
if (!rex::getUser()->isAdmin()) {
throw new rex_api_exception('You do not have the permission!');
}
$installAddon = rex_addon::get('install');
$versions = self::getVersions();
$versionId = rex_request('version_id', 'int');
if (!isset($versions[$versionId])) {
return null;
}
$version = $versions[$versionId];
if (!rex_string::versionCompare($version['version'], rex::getVersion(), '>')) {
throw new rex_api_exception(sprintf('Existing version of Core (%s) is newer than %s', rex::getVersion(), $version['version']));
}
try {
$archivefile = rex_install_webservice::getArchive($version['path']);
} catch (rex_functional_exception $e) {
throw new rex_api_exception($e->getMessage());
}
$message = '';
$temppath = rex_path::coreCache('.new.core/');
try {
if ($version['checksum'] != md5_file($archivefile)) {
throw new rex_functional_exception($installAddon->i18n('warning_zip_wrong_checksum'));
}
if (!rex_install_archive::extract($archivefile, $temppath)) {
throw new rex_functional_exception($installAddon->i18n('warning_core_zip_not_extracted'));
}
if (!is_dir($temppath . 'core')) {
throw new rex_functional_exception($installAddon->i18n('warning_zip_wrong_format'));
}
$coreAddons = [];
/** @var rex_addon[] $updateAddons */
$updateAddons = [];
if (is_dir($temppath . 'addons')) {
foreach (rex_finder::factory($temppath . 'addons')->dirsOnly() as $dir) {
$addonkey = $dir->getBasename();
$addonPath = $dir->getRealPath() . '/';
if (!file_exists($addonPath . rex_package::FILE_PACKAGE)) {
continue;
}
$config = rex_file::getConfig($addonPath . rex_package::FILE_PACKAGE);
if (!isset($config['version']) || rex_addon::exists($addonkey) && rex_string::versionCompare($config['version'], rex_addon::get($addonkey)->getVersion(), '<')) {
continue;
}
$coreAddons[$addonkey] = $addonkey;
if (rex_addon::exists($addonkey)) {
$updateAddons[$addonkey] = rex_addon::get($addonkey);
$updateAddonsConfig[$addonkey] = $config;
}
}
}
//$config = rex_file::getConfig($temppath . 'core/default.config.yml');
//foreach ($config['system_addons'] as $addonkey) {
// if (is_dir($temppath . 'addons/' . $addonkey) && rex_addon::exists($addonkey)) {
// $updateAddons[$addonkey] = rex_addon::get($addonkey);
// }
//}
$this->checkRequirements($temppath, $version['version'], $updateAddonsConfig);
if (file_exists($temppath . 'core/update.php')) {
include $temppath . 'core/update.php';
}
foreach ($updateAddons as $addonkey => $addon) {
if ($addon->isInstalled() && file_exists($file = $temppath . 'addons/' . $addonkey . '/' . rex_package::FILE_UPDATE)) {
try {
$addon->includeFile($file);
if ($msg = $addon->getProperty('updatemsg', '')) {
throw new rex_functional_exception($msg);
}
if (!$addon->getProperty('update', true)) {
throw new rex_functional_exception(rex_i18n::msg('package_no_reason'));
}
} catch (rex_functional_exception $e) {
throw new rex_functional_exception($addonkey . ': ' . $e->getMessage(), $e);
} catch (rex_sql_exception $e) {
throw new rex_functional_exception($addonkey . ': SQL error: ' . $e->getMessage(), $e);
}
}
}
// create backup
$installConfig = rex_file::getCache($installAddon->getDataPath('config.json'));
if (isset($installConfig['backups']) && $installConfig['backups']) {
rex_dir::create($installAddon->getDataPath());
$archive = $installAddon->getDataPath(strtolower(preg_replace('/[^a-z0-9-_.]/i', '_', rex::getVersion())) . '.zip');
rex_install_archive::copyDirToArchive(rex_path::core(), $archive);
foreach ($updateAddons as $addonkey => $addon) {
rex_install_archive::copyDirToArchive($addon->getPath(), $archive, 'addons/' . $addonkey);
}
}
// copy plugins to new addon dirs
foreach ($updateAddons as $addonkey => $addon) {
foreach ($addon->getRegisteredPlugins() as $plugin) {
$pluginPath = $temppath . 'addons/' . $addonkey . '/plugins/' . $plugin->getName();
if (!is_dir($pluginPath)) {
rex_dir::copy($plugin->getPath(), $pluginPath);
} elseif ($plugin->isInstalled() && is_dir($pluginPath . '/assets')) {
rex_dir::copy($pluginPath . '/assets', $plugin->getAssetsPath());
}
}
}
// move temp dirs to permanent destination
rex_dir::delete(rex_path::core());
rename($temppath . 'core', rex_path::core());
if (is_dir(rex_path::core('assets'))) {
rex_dir::copy(rex_path::core('assets'), rex_path::coreAssets());
}
foreach ($coreAddons as $addonkey) {
if (isset($updateAddons[$addonkey])) {
rex_dir::delete(rex_path::addon($addonkey));
}
rename($temppath . 'addons/' . $addonkey, rex_path::addon($addonkey));
if (is_dir(rex_path::addon($addonkey, 'assets'))) {
rex_dir::copy(rex_path::addon($addonkey, 'assets'), rex_path::addonAssets($addonkey));
}
}
} catch (rex_functional_exception $e) {
$message = $e->getMessage();
} catch (rex_sql_exception $e) {
$message = 'SQL error: ' . $e->getMessage();
}
rex_file::delete($archivefile);
rex_dir::delete($temppath);
if ($message) {
$message = $installAddon->i18n('warning_core_not_updated') . '<br />' . $message;
$success = false;
} else {
$message = $installAddon->i18n('info_core_updated');
$success = true;
rex_delete_cache();
rex_install_webservice::deleteCache('core');
}
$result = new rex_api_result($success, $message);
if ($success) {
$result->setRequiresReboot(true);
}
return $result;
}
/**
* Returns the locales.
*
* @return array Array of Locales
*/
public static function getLocales()
{
if (empty(self::$locales) && isset(self::$directories[0]) && is_readable(self::$directories[0])) {
self::$locales = [];
foreach (rex_finder::factory(self::$directories[0])->filesOnly() as $file) {
if (preg_match("/^(\\w+)\\.lang\$/", $file->getFilename(), $matches)) {
self::$locales[] = $matches[1];
}
}
}
return self::$locales;
}
/**
* Returns the subfolders of the given folder.
*
* @param string $folder Folder
*
* @return string[]
*/
private static function readPackageFolder($folder)
{
$packages = [];
if (is_dir($folder)) {
foreach (rex_finder::factory($folder)->dirsOnly() as $file) {
$packages[] = $file->getBasename();
}
}
return $packages;
}
$formElements = [];
$n = [];
$n['header'] = '<div id="rex-js-exporttype-sql-div">';
$n['label'] = '<label for="rex-form-exporttables">' . rex_i18n::msg('backup_export_select_tables') . '</label>';
$n['field'] = $tableSelect->get();
$n['footer'] = '</div>';
$formElements[] = $n;
// Vorhandene Exporte auslesen
$sel_dirs = new rex_select();
$sel_dirs->setId('rex-form-exportdir');
$sel_dirs->setName('EXPDIR[]');
$sel_dirs->setMultiple();
$sel_dirs->setSelected($EXPDIR);
$sel_dirs->setStyle('class="form-control"');
$dir = rex_path::frontend();
$folders = rex_finder::factory($dir)->dirsOnly()->ignoreDirs('.*')->ignoreDirs('redaxo');
$folders = iterator_to_array($folders);
$count_folders = count($folders);
if ($count_folders > 4) {
$sel_dirs->setSize($count_folders);
}
foreach ($folders as $file) {
$file = basename($file);
$sel_dirs->addOption($file, $file);
}
$n = [];
$n['header'] = '<div id="rex-js-exporttype-files-div" style="display: none;">';
$n['label'] = '<label for="rex-form-exportdir">' . rex_i18n::msg('backup_export_select_dir') . '</label>';
$n['field'] = $sel_dirs->get();
$n['footer'] = '</div>';
$formElements[] = $n;
/**
* Deletes the files in a directory
*
* @param string $dir Path of the directory
* @param boolean $recursive When FALSE, files in subdirectories won't be deleted
* @return boolean TRUE on success, FALSE on failure
*/
public static function deleteFiles($dir, $recursive = true)
{
$iterator = rex_finder::factory($dir)->recursive($recursive)->filesOnly()->ignoreSystemStuff(false);
return self::deleteIterator($iterator);
}
<?php
// *************************************** SYNC FUNCTIONS
// ----- SYNC DB WITH FILES DIR
if ($PERMALL) {
// ---- Dateien aus dem Ordner lesen
$folder_files = [];
$path = rex_path::media();
$iterator = rex_finder::factory($path)->filesOnly()->ignoreFiles(['.*', rex::getTempPrefix() . '*'])->sort();
foreach ($iterator as $file) {
$folder_files[] = $file->getFilename();
}
// ---- Dateien aus der DB lesen
$db = rex_sql::factory();
$db->setQuery('SELECT * FROM ' . rex::getTablePrefix() . 'media');
$db_files = [];
$db_filenames = [];
foreach ($db->getArray() as $db_file) {
$db_filenames[] = $db_file['filename'];
$db_files[] = $db_file;
}
$diff_files = array_diff($folder_files, $db_filenames);
$diff_count = count($diff_files);
// Extra - filesize/width/height DB-Filesystem Sync
foreach ($db_files as $db_file) {
$file_filesize = filesize(rex_path::media($db_file['filename']));
if ($db_file['filesize'] != $file_filesize) {
$file_sql = rex_sql::factory();
$file_sql->debugsql = 1;
$file_sql->setTable(rex::getTable('media'));
$file_sql->setWhere(['filename' => $db_file['filename']]);
public function testIgnoreSystemStuff()
{
$iterator = rex_finder::factory($this->getPath())->recursive()->ignoreSystemStuff(false);
$this->assertIteratorContains($iterator, ['file1.txt', 'file2.yml', 'dir1', 'dir1/file3.txt', 'dir1/dir', 'dir2', 'dir2/file4.yml', 'dir2/dir', 'dir2/dir/file5.yml', 'dir2/dir1', 'dir', '.DS_Store', 'dir1/Thumbs.db']);
}
