Civi/Core/Container.php

   1 <?php
   2 namespace Civi\Core;
   3
   4 use Civi\Core\Event\SystemInstallEvent;
   5 use Civi\Core\Lock\LockManager;
   6 use Symfony\Component\Config\ConfigCache;
   7 use Symfony\Component\DependencyInjection\ContainerBuilder;
   8 use Symfony\Component\DependencyInjection\Definition;
   9 use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
  10 use Symfony\Component\DependencyInjection\Reference;
  11 use Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass;
  12
  13 // TODO use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
  14
  15 /**
  16  * Class Container
  17  * @package Civi\Core
  18  */
  19 class Container {
  20
  21   const SELF = 'civi_container_factory';
  22
  23   /**
  24    * @param bool $reset
  25    *   Whether to forcibly rebuild the entire container.
  26    * @return \Symfony\Component\DependencyInjection\TaggedContainerInterface
  27    */
  28   public static function singleton($reset = FALSE) {
  29     if ($reset || !isset(\Civi::$statics[__CLASS__]['container'])) {
  30       self::boot(TRUE);
  31     }
  32     return \Civi::$statics[__CLASS__]['container'];
  33   }
  34
  35   /**
  36    * Find a cached container definition or construct a new one.
  37    *
  38    * There are many weird contexts in which Civi initializes (eg different
  39    * variations of multitenancy and different permutations of CMS/CRM bootstrap),
  40    * and hook_container may fire a bit differently in each context. To mitigate
  41    * risk of leaks between environments, we compute a unique envID
  42    * (md5(DB_NAME, HTTP_HOST, SCRIPT_FILENAME, etc)) and use separate caches for
  43    * each (eg "templates_c/CachedCiviContainer.$ENVID.php").
  44    *
  45    * Constants:
  46    *   - CIVICRM_CONTAINER_CACHE -- 'always' [default], 'never', 'auto'
  47    *   - CIVICRM_DSN
  48    *   - CIVICRM_DOMAIN_ID
  49    *
  50    * @return \Symfony\Component\DependencyInjection\ContainerInterface
  51    */
  52   public function loadContainer() {
  53     // Note: The container's raison d'etre is to manage construction of other
  54     // services. Consequently, we assume a minimal service available -- the classloader
  55     // has been setup, and civicrm.settings.php is loaded, but nothing else works.
  56
  57     $cacheMode = defined('CIVICRM_CONTAINER_CACHE') ? CIVICRM_CONTAINER_CACHE : 'auto';
  58
  59     // In pre-installation environments, don't bother with caching.
  60     if (!defined('CIVICRM_DSN') || $cacheMode === 'never' || \CRM_Utils_System::isInUpgradeMode()) {
  61       $containerBuilder = $this->createContainer();
  62       $containerBuilder->compile();
  63       return $containerBuilder;
  64     }
  65
  66     $envId = \CRM_Core_Config_Runtime::getId();
  67     $file = \Civi::paths()->getPath("[civicrm.compile]/CachedCiviContainer.{$envId}.php");
  68     $containerConfigCache = new ConfigCache($file, $cacheMode === 'auto');
  69     if (!$containerConfigCache->isFresh()) {
  70       $containerBuilder = $this->createContainer();
  71       $containerBuilder->compile();
  72       $dumper = new PhpDumper($containerBuilder);
  73       $containerConfigCache->write(
  74         $dumper->dump(['class' => 'CachedCiviContainer']),
  75         $containerBuilder->getResources()
  76       );
  77     }
  78
  79     require_once $file;
  80     $c = new \CachedCiviContainer();
  81     return $c;
  82   }
  83
  84   /**
  85    * Construct a new container.
  86    *
  87    * @var \Symfony\Component\DependencyInjection\ContainerBuilder
  88    * @return \Symfony\Component\DependencyInjection\ContainerBuilder
  89    */
  90   public function createContainer() {
  91     $civicrm_base_path = dirname(dirname(__DIR__));
  92     $container = new ContainerBuilder();
  93     $container->addCompilerPass(new RegisterListenersPass('dispatcher'));
  94     $container->addObjectResource($this);
  95     $container->setParameter('civicrm_base_path', $civicrm_base_path);
  96     //$container->set(self::SELF, $this);
  97
  98     $container->addResource(new \Symfony\Component\Config\Resource\FileResource(__FILE__));
  99
 100     $container->setDefinition(self::SELF, new Definition(
 101       'Civi\Core\Container',
 102       []
 103     ));
 104
 105     // TODO Move configuration to an external file; define caching structure
 106     //    if (empty($configDirectories)) {
 107     //      throw new \Exception(__CLASS__ . ': Missing required properties (civicrmRoot, configDirectories)');
 108     //    }
 109     //    $locator = new FileLocator($configDirectories);
 110     //    $loaderResolver = new LoaderResolver(array(
 111     //      new YamlFileLoader($container, $locator)
 112     //    ));
 113     //    $delegatingLoader = new DelegatingLoader($loaderResolver);
 114     //    foreach (array('services.yml') as $file) {
 115     //      $yamlUserFiles = $locator->locate($file, NULL, FALSE);
 116     //      foreach ($yamlUserFiles as $file) {
 117     //        $delegatingLoader->load($file);
 118     //      }
 119     //    }
 120
 121     $container->setDefinition('angular', new Definition(
 122       'Civi\Angular\Manager',
 123       []
 124     ))
 125       ->setFactory([new Reference(self::SELF), 'createAngularManager']);
 126
 127     $container->setDefinition('dispatcher', new Definition(
 128       'Civi\Core\CiviEventDispatcher',
 129       [new Reference('service_container')]
 130     ))
 131       ->setFactory([new Reference(self::SELF), 'createEventDispatcher']);
 132
 133     $container->setDefinition('magic_function_provider', new Definition(
 134       'Civi\API\Provider\MagicFunctionProvider',
 135       []
 136     ));
 137
 138     $container->setDefinition('civi_api_kernel', new Definition(
 139       'Civi\API\Kernel',
 140       [new Reference('dispatcher'), new Reference('magic_function_provider')]
 141     ))
 142       ->setFactory([new Reference(self::SELF), 'createApiKernel']);
 143
 144     $container->setDefinition('cxn_reg_client', new Definition(
 145       'Civi\Cxn\Rpc\RegistrationClient',
 146       []
 147     ))
 148       ->setFactory('CRM_Cxn_BAO_Cxn::createRegistrationClient');
 149
 150     $container->setDefinition('psr_log', new Definition('CRM_Core_Error_Log', []));
 151
 152     $basicCaches = [
 153       'js_strings' => 'js_strings',
 154       'community_messages' => 'community_messages',
 155       'checks' => 'checks',
 156       'session' => 'CiviCRM Session',
 157       'long' => 'long',
 158       'groups' => 'contact groups',
 159       'navigation' => 'navigation',
 160       'customData' => 'custom data',
 161       'fields' => 'contact fields',
 162       'contactTypes' => 'contactTypes',
 163     ];
 164     foreach ($basicCaches as $cacheSvc => $cacheGrp) {
 165       $definitionParams = [
 166         'name' => $cacheGrp,
 167         'type' => ['*memory*', 'SqlGroup', 'ArrayCache'],
 168       ];
 169       // For Caches that we don't really care about the ttl for and/or maybe accessed
 170       // fairly often we use the fastArrayDecorator which improves reads and writes, these
 171       // caches should also not have concurrency risk.
 172       $fastArrayCaches = ['groups', 'navigation', 'customData', 'fields', 'contactTypes'];
 173       if (in_array($cacheSvc, $fastArrayCaches)) {
 174         $definitionParams['withArray'] = 'fast';
 175       }
 176       $container->setDefinition("cache.{$cacheSvc}", new Definition(
 177         'CRM_Utils_Cache_Interface',
 178         [$definitionParams]
 179       ))->setFactory('CRM_Utils_Cache::create');
 180     }
 181
 182     // PrevNextCache cannot use memory or array cache at the moment because the
 183     // Code in CRM_Core_BAO_PrevNextCache assumes that this cache is sql backed.
 184     $container->setDefinition("cache.prevNextCache", new Definition(
 185       'CRM_Utils_Cache_Interface',
 186       [
 187         [
 188           'name' => 'CiviCRM Search PrevNextCache',
 189           'type' => ['SqlGroup'],
 190         ],
 191       ]
 192     ))->setFactory('CRM_Utils_Cache::create');
 193
 194     $container->setDefinition('sql_triggers', new Definition(
 195       'Civi\Core\SqlTriggers',
 196       []
 197     ));
 198
 199     $container->setDefinition('asset_builder', new Definition(
 200       'Civi\Core\AssetBuilder',
 201       []
 202     ));
 203
 204     $container->setDefinition('themes', new Definition(
 205       'Civi\Core\Themes',
 206       []
 207     ));
 208
 209     $container->setDefinition('pear_mail', new Definition('Mail'))
 210       ->setFactory('CRM_Utils_Mail::createMailer');
 211
 212     if (empty(\Civi::$statics[__CLASS__]['boot'])) {
 213       throw new \RuntimeException("Cannot initialize container. Boot services are undefined.");
 214     }
 215     foreach (\Civi::$statics[__CLASS__]['boot'] as $bootService => $def) {
 216       $container->setDefinition($bootService, new Definition())->setSynthetic(TRUE);
 217     }
 218
 219     // Expose legacy singletons as services in the container.
 220     $singletons = [
 221       'httpClient' => 'CRM_Utils_HttpClient',
 222       'cache.default' => 'CRM_Utils_Cache',
 223       'i18n' => 'CRM_Core_I18n',
 224       // Maybe? 'config' => 'CRM_Core_Config',
 225       // Maybe? 'smarty' => 'CRM_Core_Smarty',
 226     ];
 227     foreach ($singletons as $name => $class) {
 228       $container->setDefinition($name, new Definition(
 229         $class
 230       ))
 231         ->setFactory([$class, 'singleton']);
 232     }
 233     $container->setAlias('cache.short', 'cache.default');
 234
 235     $container->setDefinition('resources', new Definition(
 236       'CRM_Core_Resources',
 237       [new Reference('service_container')]
 238     ))->setFactory([new Reference(self::SELF), 'createResources']);
 239
 240     $container->setDefinition('prevnext', new Definition(
 241       'CRM_Core_PrevNextCache_Interface',
 242       [new Reference('service_container')]
 243     ))->setFactory([new Reference(self::SELF), 'createPrevNextCache']);
 244
 245     $container->setDefinition('prevnext.driver.sql', new Definition(
 246       'CRM_Core_PrevNextCache_Sql',
 247       []
 248     ));
 249
 250     $container->setDefinition('prevnext.driver.redis', new Definition(
 251       'CRM_Core_PrevNextCache_Redis',
 252       [new Reference('cache_config')]
 253     ));
 254
 255     $container->setDefinition('cache_config', new Definition('ArrayObject'))
 256       ->setFactory([new Reference(self::SELF), 'createCacheConfig']);
 257
 258     $container->setDefinition('civi.mailing.triggers', new Definition(
 259       'Civi\Core\SqlTrigger\TimestampTriggers',
 260       ['civicrm_mailing', 'Mailing']
 261     ))->addTag('kernel.event_listener', ['event' => 'hook_civicrm_triggerInfo', 'method' => 'onTriggerInfo']);
 262
 263     $container->setDefinition('civi.activity.triggers', new Definition(
 264       'Civi\Core\SqlTrigger\TimestampTriggers',
 265       ['civicrm_activity', 'Activity']
 266     ))->addTag('kernel.event_listener', ['event' => 'hook_civicrm_triggerInfo', 'method' => 'onTriggerInfo']);
 267
 268     $container->setDefinition('civi.case.triggers', new Definition(
 269       'Civi\Core\SqlTrigger\TimestampTriggers',
 270       ['civicrm_case', 'Case']
 271     ))->addTag('kernel.event_listener', ['event' => 'hook_civicrm_triggerInfo', 'method' => 'onTriggerInfo']);
 272
 273     $container->setDefinition('civi.case.staticTriggers', new Definition(
 274       'Civi\Core\SqlTrigger\StaticTriggers',
 275       [
 276         [
 277           [
 278             'upgrade_check' => ['table' => 'civicrm_case', 'column' => 'modified_date'],
 279             'table' => 'civicrm_case_activity',
 280             'when' => 'AFTER',
 281             'event' => ['INSERT'],
 282             'sql' => "\nUPDATE civicrm_case SET modified_date = CURRENT_TIMESTAMP WHERE id = NEW.case_id;\n",
 283           ],
 284           [
 285             'upgrade_check' => ['table' => 'civicrm_case', 'column' => 'modified_date'],
 286             'table' => 'civicrm_activity',
 287             'when' => 'BEFORE',
 288             'event' => ['UPDATE', 'DELETE'],
 289             'sql' => "\nUPDATE civicrm_case SET modified_date = CURRENT_TIMESTAMP WHERE id IN (SELECT ca.case_id FROM civicrm_case_activity ca WHERE ca.activity_id = OLD.id);\n",
 290           ],
 291         ],
 292       ]
 293     ))
 294       ->addTag('kernel.event_listener', ['event' => 'hook_civicrm_triggerInfo', 'method' => 'onTriggerInfo']);
 295
 296     $container->setDefinition('civi_token_compat', new Definition(
 297       'Civi\Token\TokenCompatSubscriber',
 298       []
 299     ))->addTag('kernel.event_subscriber');
 300     $container->setDefinition("crm_mailing_action_tokens", new Definition(
 301       "CRM_Mailing_ActionTokens",
 302       []
 303     ))->addTag('kernel.event_subscriber');
 304
 305     foreach (['Activity', 'Contribute', 'Event', 'Mailing', 'Member'] as $comp) {
 306       $container->setDefinition("crm_" . strtolower($comp) . "_tokens", new Definition(
 307         "CRM_{$comp}_Tokens",
 308         []
 309       ))->addTag('kernel.event_subscriber');
 310     }
 311
 312     if (\CRM_Utils_Constant::value('CIVICRM_FLEXMAILER_HACK_SERVICES')) {
 313       \Civi\Core\Resolver::singleton()->call(CIVICRM_FLEXMAILER_HACK_SERVICES, [$container]);
 314     }
 315
 316     \CRM_Utils_Hook::container($container);
 317
 318     return $container;
 319   }
 320
 321   /**
 322    * @return \Civi\Angular\Manager
 323    */
 324   public function createAngularManager() {
 325     return new \Civi\Angular\Manager(\CRM_Core_Resources::singleton());
 326   }
 327
 328   /**
 329    * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
 330    * @return \Symfony\Component\EventDispatcher\ContainerAwareEventDispatcher
 331    */
 332   public function createEventDispatcher($container) {
 333     $dispatcher = new CiviEventDispatcher($container);
 334     $dispatcher->addListener(SystemInstallEvent::EVENT_NAME, ['\Civi\Core\InstallationCanary', 'check']);
 335     $dispatcher->addListener(SystemInstallEvent::EVENT_NAME, ['\Civi\Core\DatabaseInitializer', 'initialize']);
 336     $dispatcher->addListener(SystemInstallEvent::EVENT_NAME, ['\Civi\Core\LocalizationInitializer', 'initialize']);
 337     $dispatcher->addListener('hook_civicrm_pre', ['\Civi\Core\Event\PreEvent', 'dispatchSubevent'], 100);
 338     $dispatcher->addListener('hook_civicrm_post', ['\Civi\Core\Event\PostEvent', 'dispatchSubevent'], 100);
 339     $dispatcher->addListener('hook_civicrm_post::Activity', ['\Civi\CCase\Events', 'fireCaseChange']);
 340     $dispatcher->addListener('hook_civicrm_post::Case', ['\Civi\CCase\Events', 'fireCaseChange']);
 341     $dispatcher->addListener('hook_civicrm_caseChange', ['\Civi\CCase\Events', 'delegateToXmlListeners']);
 342     $dispatcher->addListener('hook_civicrm_caseChange', ['\Civi\CCase\SequenceListener', 'onCaseChange_static']);
 343     $dispatcher->addListener('hook_civicrm_eventDefs', ['\Civi\Core\CiviEventInspector', 'findBuiltInEvents']);
 344     // TODO We need a better code-convention for metadata about non-hook events.
 345     $dispatcher->addListener('hook_civicrm_eventDefs', ['\Civi\API\Events', 'hookEventDefs']);
 346     $dispatcher->addListener('hook_civicrm_eventDefs', ['\Civi\Core\Event\SystemInstallEvent', 'hookEventDefs']);
 347     $dispatcher->addListener('hook_civicrm_buildAsset', ['\Civi\Angular\Page\Modules', 'buildAngularModules']);
 348     $dispatcher->addListener('hook_civicrm_buildAsset', ['\CRM_Utils_VisualBundle', 'buildAssetJs']);
 349     $dispatcher->addListener('hook_civicrm_buildAsset', ['\CRM_Utils_VisualBundle', 'buildAssetCss']);
 350     $dispatcher->addListener('hook_civicrm_buildAsset', ['\CRM_Core_Resources', 'renderMenubarStylesheet']);
 351     $dispatcher->addListener('hook_civicrm_coreResourceList', ['\CRM_Utils_System', 'appendCoreResources']);
 352     $dispatcher->addListener('hook_civicrm_getAssetUrl', ['\CRM_Utils_System', 'alterAssetUrl']);
 353     $dispatcher->addListener('civi.dao.postInsert', ['\CRM_Core_BAO_RecurringEntity', 'triggerInsert']);
 354     $dispatcher->addListener('civi.dao.postUpdate', ['\CRM_Core_BAO_RecurringEntity', 'triggerUpdate']);
 355     $dispatcher->addListener('civi.dao.postDelete', ['\CRM_Core_BAO_RecurringEntity', 'triggerDelete']);
 356     $dispatcher->addListener('hook_civicrm_unhandled_exception', [
 357       'CRM_Core_LegacyErrorHandler',
 358       'handleException',
 359     ], -200);
 360     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Activity_ActionMapping', 'onRegisterActionMappings']);
 361     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Contact_ActionMapping', 'onRegisterActionMappings']);
 362     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Contribute_ActionMapping_ByPage', 'onRegisterActionMappings']);
 363     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Contribute_ActionMapping_ByType', 'onRegisterActionMappings']);
 364     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Event_ActionMapping', 'onRegisterActionMappings']);
 365     $dispatcher->addListener(\Civi\ActionSchedule\Events::MAPPINGS, ['CRM_Member_ActionMapping', 'onRegisterActionMappings']);
 366
 367     if (\CRM_Utils_Constant::value('CIVICRM_FLEXMAILER_HACK_LISTENERS')) {
 368       \Civi\Core\Resolver::singleton()->call(CIVICRM_FLEXMAILER_HACK_LISTENERS, [$dispatcher]);
 369     }
 370
 371     return $dispatcher;
 372   }
 373
 374   /**
 375    * @return \Civi\Core\Lock\LockManager
 376    */
 377   public static function createLockManager() {
 378     // Ideally, downstream implementers could override any definitions in
 379     // the container. For now, we'll make-do with some define()s.
 380     $lm = new LockManager();
 381     $lm
 382       ->register('/^cache\./', defined('CIVICRM_CACHE_LOCK') ? CIVICRM_CACHE_LOCK : ['CRM_Core_Lock', 'createScopedLock'])
 383       ->register('/^data\./', defined('CIVICRM_DATA_LOCK') ? CIVICRM_DATA_LOCK : ['CRM_Core_Lock', 'createScopedLock'])
 384       ->register('/^worker\.mailing\.send\./', defined('CIVICRM_WORK_LOCK') ? CIVICRM_WORK_LOCK : ['CRM_Core_Lock', 'createCivimailLock'])
 385       ->register('/^worker\./', defined('CIVICRM_WORK_LOCK') ? CIVICRM_WORK_LOCK : ['CRM_Core_Lock', 'createScopedLock']);
 386
 387     // Registrations may use complex resolver expressions, but (as a micro-optimization)
 388     // the default factory is specified as an array.
 389
 390     return $lm;
 391   }
 392
 393   /**
 394    * @param \Symfony\Component\EventDispatcher\EventDispatcher $dispatcher
 395    * @param $magicFunctionProvider
 396    *
 397    * @return \Civi\API\Kernel
 398    */
 399   public function createApiKernel($dispatcher, $magicFunctionProvider) {
 400     $dispatcher->addSubscriber(new \Civi\API\Subscriber\ChainSubscriber());
 401     $dispatcher->addSubscriber(new \Civi\API\Subscriber\TransactionSubscriber());
 402     $dispatcher->addSubscriber(new \Civi\API\Subscriber\I18nSubscriber());
 403     $dispatcher->addSubscriber($magicFunctionProvider);
 404     $dispatcher->addSubscriber(new \Civi\API\Subscriber\PermissionCheck());
 405     $dispatcher->addSubscriber(new \Civi\API\Subscriber\APIv3SchemaAdapter());
 406     $dispatcher->addSubscriber(new \Civi\API\Subscriber\WrapperAdapter([
 407       \CRM_Utils_API_HTMLInputCoder::singleton(),
 408       \CRM_Utils_API_NullOutputCoder::singleton(),
 409       \CRM_Utils_API_ReloadOption::singleton(),
 410       \CRM_Utils_API_MatchOption::singleton(),
 411     ]));
 412     $dispatcher->addSubscriber(new \Civi\API\Subscriber\XDebugSubscriber());
 413     $kernel = new \Civi\API\Kernel($dispatcher);
 414
 415     $reflectionProvider = new \Civi\API\Provider\ReflectionProvider($kernel);
 416     $dispatcher->addSubscriber($reflectionProvider);
 417
 418     $dispatcher->addSubscriber(new \Civi\API\Subscriber\DynamicFKAuthorization(
 419       $kernel,
 420       'Attachment',
 421       ['create', 'get', 'delete'],
 422       // Given a file ID, determine the entity+table it's attached to.
 423       'SELECT if(cf.id,1,0) as is_valid, cef.entity_table, cef.entity_id
 424          FROM civicrm_file cf
 425          LEFT JOIN civicrm_entity_file cef ON cf.id = cef.file_id
 426          WHERE cf.id = %1',
 427       // Get a list of custom fields (field_name,table_name,extends)
 428       'SELECT concat("custom_",fld.id) as field_name,
 429         grp.table_name as table_name,
 430         grp.extends as extends
 431        FROM civicrm_custom_field fld
 432        INNER JOIN civicrm_custom_group grp ON fld.custom_group_id = grp.id
 433        WHERE fld.data_type = "File"
 434       ',
 435       ['civicrm_activity', 'civicrm_mailing', 'civicrm_contact', 'civicrm_grant']
 436     ));
 437
 438     $kernel->setApiProviders([
 439       $reflectionProvider,
 440       $magicFunctionProvider,
 441     ]);
 442
 443     return $kernel;
 444   }
 445
 446   /**
 447    * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
 448    * @return \CRM_Core_Resources
 449    */
 450   public static function createResources($container) {
 451     $sys = \CRM_Extension_System::singleton();
 452     return new \CRM_Core_Resources(
 453       $sys->getMapper(),
 454       $container->get('cache.js_strings'),
 455       \CRM_Core_Config::isUpgradeMode() ? NULL : 'resCacheCode'
 456     );
 457   }
 458
 459   /**
 460    * @param \Symfony\Component\DependencyInjection\ContainerInterface $container
 461    * @return \CRM_Core_PrevNextCache_Interface
 462    */
 463   public static function createPrevNextCache($container) {
 464     $setting = \Civi::settings()->get('prevNextBackend');
 465     if ($setting === 'default') {
 466       // For initial release (5.8.x), continue defaulting to SQL.
 467       $isTransitional = version_compare(\CRM_Utils_System::version(), '5.9.alpha1', '<');
 468       $cacheDriver = \CRM_Utils_Cache::getCacheDriver();
 469       $service = 'prevnext.driver.' . strtolower($cacheDriver);
 470       return $container->has($service) && !$isTransitional
 471         ? $container->get($service)
 472         : $container->get('prevnext.driver.sql');
 473     }
 474     else {
 475       return $container->get('prevnext.driver.' . $setting);
 476     }
 477   }
 478
 479   public static function createCacheConfig() {
 480     $driver = \CRM_Utils_Cache::getCacheDriver();
 481     $settings = \CRM_Utils_Cache::getCacheSettings($driver);
 482     $settings['driver'] = $driver;
 483     return new \ArrayObject($settings);
 484   }
 485
 486   /**
 487    * Get a list of boot services.
 488    *
 489    * These are services which must be setup *before* the container can operate.
 490    *
 491    * @param bool $loadFromDB
 492    * @throws \CRM_Core_Exception
 493    */
 494   public static function boot($loadFromDB) {
 495     // Array(string $serviceId => object $serviceInstance).
 496     $bootServices = [];
 497     \Civi::$statics[__CLASS__]['boot'] = &$bootServices;
 498
 499     $bootServices['runtime'] = $runtime = new \CRM_Core_Config_Runtime();
 500     $runtime->initialize($loadFromDB);
 501
 502     $bootServices['paths'] = new \Civi\Core\Paths();
 503
 504     $class = $runtime->userFrameworkClass;
 505     $bootServices['userSystem'] = $userSystem = new $class();
 506     $userSystem->initialize();
 507
 508     $userPermissionClass = 'CRM_Core_Permission_' . $runtime->userFramework;
 509     $bootServices['userPermissionClass'] = new $userPermissionClass();
 510
 511     $bootServices['cache.settings'] = \CRM_Utils_Cache::create([
 512       'name' => 'settings',
 513       'type' => ['*memory*', 'SqlGroup', 'ArrayCache'],
 514     ]);
 515
 516     $bootServices['settings_manager'] = new \Civi\Core\SettingsManager($bootServices['cache.settings']);
 517
 518     $bootServices['lockManager'] = self::createLockManager();
 519
 520     if ($loadFromDB && $runtime->dsn) {
 521       \CRM_Core_DAO::init($runtime->dsn);
 522       \CRM_Utils_Hook::singleton(TRUE);
 523       \CRM_Extension_System::singleton(TRUE);
 524       \CRM_Extension_System::singleton(TRUE)->getClassLoader()->register();
 525
 526       $runtime->includeCustomPath();
 527
 528       $c = new self();
 529       $container = $c->loadContainer();
 530       foreach ($bootServices as $name => $obj) {
 531         $container->set($name, $obj);
 532       }
 533       \Civi::$statics[__CLASS__]['container'] = $container;
 534     }
 535   }
 536
 537   public static function getBootService($name) {
 538     return \Civi::$statics[__CLASS__]['boot'][$name];
 539   }
 540
 541   /**
 542    * Determine whether the container services are available.
 543    *
 544    * @return bool
 545    */
 546   public static function isContainerBooted() {
 547     return isset(\Civi::$statics[__CLASS__]['container']);
 548   }
 549
 550 }