/**
* Test eZSys $AccessPath as it worked prior to 4.4 without propertied to
* define scope of path with RemoveSiteAccessIfDefaultAccess=disabled
*/
public function testIndexFileRemoveSiteAccessIfDefaultAccessDisabled()
{
// TEST SETUP --------------------------------------------------------
$ini = eZINI::instance();
$defaultAccess = $ini->variable( 'SiteSettings', 'DefaultAccess' );
$this->setSiteAccess( $defaultAccess );
// Make sure to preserve ini settings in case other tests depend on them
$orgRemoveSiteaccess = $ini->variable( 'SiteAccessSettings', 'RemoveSiteAccessIfDefaultAccess' );
// DISABLE RemoveSiteAccessIfDefaultAccess
$ini->setVariable( 'SiteAccessSettings', 'RemoveSiteAccessIfDefaultAccess', 'disabled' );
// -------------------------------------------------------------------
// TEST --------------------------------------------------------------
$indexFile = eZSys::indexFile();
self::assertEquals( "/$defaultAccess", $indexFile );
eZSys::addAccessPath( array( 'testing', 'indexFile' ) );
$indexFile = eZSys::indexFile();
self::assertEquals( "/$defaultAccess/testing/indexFile", $indexFile );
// -------------------------------------------------------------------
// TEST TEAR DOWN ----------------------------------------------------
$ini->setVariable( 'SiteAccessSettings', 'RemoveSiteAccessIfDefaultAccess', $orgRemoveSiteaccess );
eZSys::clearAccessPath();
// -------------------------------------------------------------------
}
}
$Result = array();
$Result['content'] = '';
$Result['rerun_uri'] = '/' . implode('/', array_splice($Params['Parameters'], 1)) . $userParamString;
$layoutINI = eZINI::instance('layout.ini');
$i18nINI = eZINI::instance('i18n.ini');
if ($layoutINI->hasGroup($LayoutStyle)) {
if ($layoutINI->hasVariable($LayoutStyle, 'PageLayout')) {
$Result['pagelayout'] = $layoutINI->variable($LayoutStyle, 'PageLayout');
}
if ($layoutINI->hasVariable($LayoutStyle, 'ContentType')) {
header('Content-Type: ' . $layoutINI->variable($LayoutStyle, 'ContentType') . '; charset=' . $i18nINI->variable('CharacterSettings', 'Charset'));
}
$res = eZTemplateDesignResource::instance();
$res->setKeys(array(array('layout', $LayoutStyle)));
if ($layoutINI->hasVariable($LayoutStyle, 'UseAccessPass') && $layoutINI->variable($LayoutStyle, 'UseAccessPass') == 'false') {
} else {
eZSys::addAccessPath(array('layout', 'set', $LayoutStyle), 'layout', false);
}
$useFullUrl = false;
$http = eZHTTPTool::instance();
$http->UseFullUrl = false;
if ($layoutINI->hasVariable($LayoutStyle, 'UseFullUrl')) {
if ($layoutINI->variable($LayoutStyle, 'UseFullUrl') == 'true') {
$http->UseFullUrl = true;
}
}
$Module->setExitStatus(eZModule::STATUS_RERUN);
} else {
eZDebug::writeError('No such layout style: ' . $LayoutStyle, 'layout/set');
}
/**
* Register extensions "the YMC way".
*
*
* @return void
* @access public
* @author ymc-dabe
* @see eZExtension::activateExtensions()
* @link http://issues.ez.no/IssueView.php?Id=2709
*/
public function registerExtensions($virtual_siteaccess = false)
{
if (!$this->attribute('is_enabled')) {
eZDebug::writeError("The ymcExtensionLoader is disabled, but " . __METHOD__ . " has just been called (which really shouldn't be done)!", __METHOD__);
}
$siteaccess = self::getCurrentSiteaccess();
$isBasicLoad = true;
$is_virtual_load = false;
$cache_hit = false;
$defaultActiveExtensions = self::$alwaysEnabledExtensions;
if (!in_array('ymcextensionloader', $defaultActiveExtensions)) {
$defaultActiveExtensions[] = 'ymcextensionloader';
}
if ($this->standardLoadingCompleted === true and $virtual_siteaccess !== false and $siteaccess !== $virtual_siteaccess) {
if ($this->virtualLoadingCompleted === true) {
eZDebug::writeError("Unnecessary call to 'ymcExtensionLoader::registerExtensions('.{$virtual_siteaccess}.')'!", __METHOD__);
return;
}
$siteaccess = $virtual_siteaccess;
self::setInternalSiteaccess($siteaccess);
eZDebug::accumulatorStart('OpenVolanoExtensionLoader_VirtualSiteaccess', 'OpenVolano: Enhanced Extension Loader', "After virtual siteaccess '{$siteaccess}' initialised ");
$isBasicLoad = false;
$is_virtual_load = true;
$this->rebuildIniOverrideArray($siteaccess, $isBasicLoad);
} else {
if (null !== $siteaccess) {
if ($this->standardLoadingCompleted === true) {
eZDebug::writeError("Unnecessary call to " . __METHOD__ . "!", __METHOD__);
return;
}
$isBasicLoad = false;
eZDebug::accumulatorStart('OpenVolanoExtensionLoader_Siteaccess', 'OpenVolano: Enhanced Extension Loader', "After siteaccess '{$siteaccess}' initialised ");
} else {
if (self::$earlyLoadingCompleted === true) {
eZDebug::writeWarning("Force registering additional extensions - please keep in mind, that it is not possible to unload extensions", __METHOD__);
}
eZDebug::accumulatorStart('OpenVolanoExtensionLoader_Basic', 'OpenVolano: Enhanced Extension Loader', 'Pre siteaccess initialised');
}
}
$ini = eZINI::instance();
$allExtensionsRegistered = false;
if ($isBasicLoad) {
self::$globalCacheDirectory = eZSys::cacheDirectory();
$cacheFileName = 'basic';
$cache_var_name = 'ymcExtensionLoaderRegisterExtensionBasicLoadInformation';
} else {
if ($is_virtual_load) {
$cacheFileName = 'siteaccess-' . $this->attribute('non_virtual_siteaccess') . '-virtualsiteaccess-' . $siteaccess;
$cache_var_name = 'ymcExtensionLoaderRegisterExtensionVirtualSiteaccessLoadInformation';
} else {
$cacheFileName = 'siteaccess-' . $siteaccess;
$cache_var_name = 'ymcExtensionLoaderRegisterExtensionSiteaccessLoadInformation';
}
}
$write_cache = false;
$can_write_cache = true;
$cacheDir = eZSys::cacheDirectory() . '/openvolano/extensions';
if (!is_writable($cacheDir)) {
if (!eZDir::mkdir($cacheDir, 0777, true)) {
$can_write_cache = false;
eZDebug::writeError("Couldn't create cache directory '{$cacheDir}', perhaps wrong permissions", __METHOD__);
}
}
$cacheFilePath = $cacheDir . '/' . $cacheFileName;
if (!file_exists($cacheFilePath)) {
$write_cache = $can_write_cache;
if ($isBasicLoad) {
eZDebug::writeNotice("No cache found for loading basic set of extensions", __METHOD__);
} else {
eZDebug::writeNotice("No cache found for loading per siteaccess set of extensions for siteaccess '{$siteaccess}'", __METHOD__);
}
} else {
include $cacheFilePath;
if (!isset(${$cache_var_name})) {
eZDebug::writeWarning("Cache '{$cache_var_name}' in file '{$cacheFilePath}' not found. Trying to force rewrite of this cache file...", __METHOD__);
$write_cache = $can_write_cache;
} else {
eZDebug::writeNotice("Cache hit: {$cacheFilePath}", __METHOD__);
$defaultActiveExtensions = ${$cache_var_name};
$cache_hit = true;
unset($cache_var_name);
}
}
$additional_lookups = 0;
//Loop registering of extensions until all are loaded
while (!$allExtensionsRegistered) {
//First we asume we do not need to check for new extensions
$allExtensionsRegistered = true;
//these extensions are always active
$activeExtensions = $defaultActiveExtensions;
//Get all active extension
$activeExtensions = array_unique(array_merge($activeExtensions, eZExtension::activeExtensions()));
foreach ($activeExtensions as $activeExtension) {
//only activate an extension if it has not been registered, yet
if (!in_array($activeExtension, $this->registeredExtensions)) {
$this->registeredExtensions[] = $activeExtension;
$fullExtensionPath = eZExtension::baseDirectory() . '/' . $activeExtension;
if (!file_exists($fullExtensionPath)) {
eZDebug::writeWarning("Extension '{$activeExtension}' does not exist, looked for directory '{$fullExtensionPath}'", __METHOD__);
} else {
$fullExtensionAutoloadPath = $fullExtensionPath . '/autoload';
if ($activeExtension !== 'ymcextensionloader' and !in_array($activeExtension, self::$noAutoloadExtensions) and file_exists($fullExtensionAutoloadPath)) {
//add the new extension's autoload-dir to the eZ compontents autoload system (if needed)
ezcBase::addClassRepository($fullExtensionPath, $fullExtensionAutoloadPath);
}
//We are about to activate a new extension which might need to load one ore more other extension (if we do not have a cached info about this)
$allExtensionsRegistered = $cache_hit;
}
}
}
$this->rebuildIniOverrideArray($siteaccess, $isBasicLoad);
if (!$allExtensionsRegistered) {
$additional_lookups++;
}
}
if (!$cache_hit) {
if ($isBasicLoad) {
eZDebug::writeNotice("Loaded all basic extensions in {$additional_lookups} additional lookups...", __METHOD__);
} else {
if ($is_virtual_load) {
eZDebug::writeNotice("Loaded all virtual siteaccess extensions in {$additional_lookups} additional lookups...", __METHOD__);
} else {
eZDebug::writeNotice("Loaded all siteaccess extensions in {$additional_lookups} additional lookups...", __METHOD__);
}
}
}
if ($write_cache) {
if ($isBasicLoad) {
eZDebug::writeNotice("Storing basic extension load information into cache file '{$cacheFilePath}'...", __METHOD__);
} else {
if ($is_virtual_load) {
eZDebug::writeNotice("Storing virtual siteaccess extension load information into cache file '{$cacheFilePath}'...", __METHOD__);
} else {
eZDebug::writeNotice("Storing siteaccess extension load information into cache file '{$cacheFilePath}'...", __METHOD__);
}
}
$php = new eZPHPCreator($cacheDir, $cacheFileName);
$php->addRawVariable($cache_var_name, $this->registeredExtensions);
$php->store();
}
if ($is_virtual_load) {
$this->virtualLoadingCompleted = true;
eZDebug::accumulatorStop('OpenVolanoExtensionLoader_VirtualSiteaccess');
} else {
if (!$isBasicLoad) {
$this->standardLoadingCompleted = true;
$this->non_virtual_siteaccess_name = $siteaccess;
eZDebug::accumulatorStop('OpenVolanoExtensionLoader_Siteaccess');
} else {
self::$earlyLoadingCompleted = true;
eZDebug::accumulatorStop('OpenVolanoExtensionLoader_Basic');
}
}
//Use the following line to take a look into the ini-hierarchy...
//ymc_pr($GLOBALS["eZINIOverrideDirList"], $siteaccess.'|'.self::getCurrentSiteaccess());
if (!$is_virtual_load and !$isBasicLoad and $ini->hasVariable('SiteAccessSettings', 'VirtualSiteaccessSystem') and $ini->variable('SiteAccessSettings', 'VirtualSiteaccessSystem') !== 'disabled') {
$allowLoadingOfPreviouslyKnownSiteaccesses = false;
if ($ini->hasVariable('SiteAccessSettings', 'VirtualSiteaccessSystem') and $ini->variable('VirtualSiteaccessSettings', 'AllowLoadingOfPerviouslyKnowSiteaccesses') === 'enabled') {
$allowLoadingOfPreviouslyKnownSiteaccesses = true;
}
if (isset($GLOBALS['eZURIRequestInstance']) and is_object($GLOBALS['eZURIRequestInstance'])) {
$uri = eZURI::instance();
$elements = $uri->elements(false);
if (count($elements) > 0 and $elements[0] != '') {
$goInVirtualSiteaccessMode = true;
if ($ini->hasVariable('VirtualSiteaccessSettings', 'SkipLoadingForUri') and is_array($ini->variable('VirtualSiteaccessSettings', 'SkipLoadingForUri')) and count($ini->variable('VirtualSiteaccessSettings', 'SkipLoadingForUri')) > 0) {
$uri_string = $uri->elements(true);
foreach ($ini->variable('VirtualSiteaccessSettings', 'SkipLoadingForUri') as $ignoreUriForVirtualSiteaccess) {
if (strpos($uri_string, $ignoreUriForVirtualSiteaccess) === 0) {
$goInVirtualSiteaccessMode = false;
break;
}
}
unset($uri_string);
}
} else {
$goInVirtualSiteaccessMode = false;
}
if ($goInVirtualSiteaccessMode) {
$matchIndex = 1;
$name = $elements[0];
//by ymc-dabe //Code taken from /access.php line 241-249 of eZ publish v4.1.3 //KEEP IT IN SYNC! //start
$name = preg_replace(array('/[^a-zA-Z0-9]+/', '/_+/', '/^_/', '/_$/'), array('_', '_', '', ''), $name);
//by ymc-dabe //Code taken from /access.php line 241-249 of eZ publush v4.1.3 //KEEP IT IN SYNC! //end
if ($allowLoadingOfPreviouslyKnownSiteaccesses or !in_array($name, $ini->variable('SiteAccessSettings', 'AvailableSiteAccessList'))) {
eZSys::addAccessPath($name);
$uri->increase($matchIndex);
$uri->dropBase();
$this->registerExtensions($name);
//die if virtual siteaccess is not found
if (!in_array($name, $ini->variable('SiteAccessSettings', 'AvailableSiteAccessList'))) {
header($_SERVER['SERVER_PROTOCOL'] . " 400 Bad Request");
header("Status: 400 Bad Request");
eZExecution::cleanExit();
}
}
unset($name);
}
} else {
if (isset($GLOBALS['ymcEnhancedExtensionLoaderVirtualSiteaccess']) and $GLOBALS['ymcEnhancedExtensionLoaderVirtualSiteaccess'] != '') {
$virtualSiteaccessName = $GLOBALS['ymcEnhancedExtensionLoaderVirtualSiteaccess'];
if ($allowLoadingOfPreviouslyKnownSiteaccesses or !in_array($virtualSiteaccessName, $ini->variable('SiteAccessSettings', 'AvailableSiteAccessList'))) {
eZSys::addAccessPath($virtualSiteaccessName);
$this->registerExtensions($virtualSiteaccessName);
if (!in_array($virtualSiteaccessName, $ini->variable('SiteAccessSettings', 'AvailableSiteAccessList'))) {
fputs(STDERR, "\n----------\nError: Invalid siteaccess '{$virtualSiteaccessName}'!\n----------\n\n");
eZExecution::cleanExit();
}
}
unset($virtualSiteaccessName);
}
}
} else {
if ($this->standardLoadingCompleted === true) {
$this->virtualLoadingCompleted = true;
}
}
if ($this->standardLoadingCompleted === true) {
$this->loadingCompleted = true;
if ($this->originalNonVirtualSiteaccessName === false) {
$this->originalNonVirtualSiteaccessName = $this->attribute('non_virtual_siteaccess');
if ($this->originalVirtualSiteaccessName === false and $siteaccess != $this->attribute('non_virtual_siteaccess')) {
$this->originalVirtualSiteaccessName = $siteaccess;
}
}
}
}
