DomainConfigOverrider.php in Domain Access 8
Namespace
Drupal\domain_configFile
domain_config/src/DomainConfigOverrider.phpView source
<?php
namespace Drupal\domain_config;
use Drupal\domain\DomainInterface;
use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Config\ConfigFactoryOverrideInterface;
use Drupal\Core\Config\StorageInterface;
use Drupal\Core\Extension\ModuleHandlerInterface;
/**
* Domain-specific config overrides.
*
* @see \Drupal\language\Config\LanguageConfigFactoryOverride for ways
* this might be improved.
*/
class DomainConfigOverrider implements ConfigFactoryOverrideInterface {
/**
* The domain negotiator.
*
* @var \Drupal\domain\DomainNegotiatorInterface
*/
protected $domainNegotiator;
/**
* A storage controller instance for reading and writing configuration data.
*
* @var \Drupal\Core\Config\StorageInterface
*/
protected $storage;
/**
* The module handler.
*
* @var \Drupal\Core\Extension\ModuleHandlerInterface
*/
protected $moduleHandler;
/**
* The domain context of the request.
*
* @var \Drupal\domain\DomainInterface
*/
protected $domain;
/**
* The language context of the request.
*
* @var \Drupal\Core\Language\LanguageInterface
*/
protected $language;
/**
* Drupal language manager.
*
* Using dependency injection for this service causes a circular dependency.
*
* @var \Drupal\Core\Language\LanguageManagerInterface
*/
protected $languageManager;
/**
* Indicates that the request context is set.
*
* @var bool
*/
protected $contextSet;
/**
* Constructs a DomainConfigSubscriber object.
*
* @param \Drupal\Core\Config\StorageInterface $storage
* The configuration storage engine.
* @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
* The module handler.
*/
public function __construct(StorageInterface $storage, ModuleHandlerInterface $module_handler) {
$this->storage = $storage;
$this->moduleHandler = $module_handler;
}
/**
* {@inheritdoc}
*/
public function loadOverrides($names) {
// Assume first time loading is NULL.
static $load = NULL;
$config_override_exists = FALSE;
if (is_null($load)) {
// Ensure we don't have any values in settings.php.
$config_from_settings = array_keys($GLOBALS['config']);
foreach ($config_from_settings as $config_key) {
if (strpos($config_key, 'domain.config', 0) !== FALSE) {
$config_override_exists = TRUE;
break;
}
}
}
// Check if any overridden config exists or if we have already
// made this check.
// See https://www.drupal.org/project/domain/issues/3126532.
if ($load === FALSE || !$this->storage
->listAll('domain.config.') && !$config_override_exists) {
$load = FALSE;
return [];
}
else {
// Try to prevent repeating lookups.
static $lookups;
// Key should be a known length, so hash.
$key = md5(implode(':', $names));
if (isset($lookups[$key])) {
return $lookups[$key];
}
// Set the context of the override request.
if (empty($this->contextSet)) {
$this
->initiateContext();
}
// Prepare our overrides.
$overrides = [];
// loadOverrides() runs on config entities, which means that if we try
// to run this routine on our own data, then we end up in an infinite loop.
// So ensure that we are _not_ looking up a domain.record.*.
$check = current($names);
$list = explode('.', $check);
if (isset($list[0]) && isset($list[1]) && $list[0] == 'domain' && $list[1] == 'record') {
$lookups[$key] = $overrides;
return $overrides;
}
if (!empty($this->domain)) {
foreach ($names as $name) {
$config_name = $this
->getDomainConfigName($name, $this->domain);
// Check to see if the config storage has an appropriately named file
// containing override data.
if ($override = $this->storage
->read($config_name['langcode'])) {
$overrides[$name] = $override;
}
elseif ($override = $this->storage
->read($config_name['domain'])) {
$overrides[$name] = $override;
}
// Apply any settings.php overrides.
if (isset($GLOBALS['config'][$config_name['langcode']])) {
$overrides[$name] = $GLOBALS['config'][$config_name['langcode']];
}
elseif (isset($GLOBALS['config'][$config_name['domain']])) {
$overrides[$name] = $GLOBALS['config'][$config_name['domain']];
}
}
$lookups[$key] = $overrides;
}
return $overrides;
}
}
/**
* Get configuration name for this hostname.
*
* It will be the same name with a prefix depending on domain and language:
*
* @code domain.config.DOMAIN_ID.LANGCODE @endcode
*
* @param string $name
* The name of the config object.
* @param \Drupal\domain\DomainInterface $domain
* The domain object.
*
* @return array
* The domain-language, and domain-specific config names.
*/
protected function getDomainConfigName($name, DomainInterface $domain) {
return [
'langcode' => 'domain.config.' . $domain
->id() . '.' . $this->language
->getId() . '.' . $name,
'domain' => 'domain.config.' . $domain
->id() . '.' . $name,
];
}
/**
* {@inheritdoc}
*/
public function getCacheSuffix() {
$suffix = $this->domain ? $this->domain
->id() : '';
$suffix .= $this->language ? $this->language
->getId() : '';
return $suffix ? $suffix : NULL;
}
/**
* {@inheritdoc}
*/
public function createConfigObject($name, $collection = StorageInterface::DEFAULT_COLLECTION) {
return NULL;
}
/**
* {@inheritdoc}
*/
public function getCacheableMetadata($name) {
if (empty($this->contextSet)) {
$this
->initiateContext();
}
$metadata = new CacheableMetadata();
if (!empty($this->domain)) {
$metadata
->addCacheContexts([
'url.site',
'languages:language_interface',
]);
}
return $metadata;
}
/**
* Sets domain and language contexts for the request.
*
* We wait to do this in order to avoid circular dependencies
* with the locale module.
*/
protected function initiateContext() {
// Prevent infinite lookups by caching the request. Since the _construct()
// is called for each lookup, this is more efficient.
$this->contextSet = TRUE;
// We must ensure that modules have loaded, which they may not have.
// See https://www.drupal.org/project/domain/issues/3025541.
$this->moduleHandler
->loadAll();
// Get the language context. Note that injecting the language manager
// into the service created a circular dependency error, so we load from
// the core service manager.
$this->languageManager = \Drupal::languageManager();
$this->language = $this->languageManager
->getCurrentLanguage();
// The same issue is true for the domainNegotiator.
$this->domainNegotiator = \Drupal::service('domain.negotiator');
// Get the domain context.
$this->domain = $this->domainNegotiator
->getActiveDomain(TRUE);
}
}
Classes
Name | Description |
---|---|
DomainConfigOverrider | Domain-specific config overrides. |