vendor/symfony/doctrine-bridge/DependencyInjection/AbstractDoctrineExtension.php line 181

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bridge\Doctrine\DependencyInjection;
  14. use Symfony\Component\DependencyInjection\Alias;
  15. use Symfony\Component\DependencyInjection\ContainerBuilder;
  16. use Symfony\Component\DependencyInjection\Definition;
  17. use Symfony\Component\DependencyInjection\Reference;
  18. use Symfony\Component\HttpKernel\DependencyInjection\Extension;
  20. /**
  21.  * This abstract classes groups common code that Doctrine Object Manager extensions (ORM, MongoDB, CouchDB) need.
  22.  *
  23.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  24.  */
  25. abstract class AbstractDoctrineExtension extends Extension
  26. {
  27.     /**
  28.      * Used inside metadata driver method to simplify aggregation of data.
  29.      */
  30.     protected $aliasMap = [];
  32.     /**
  33.      * Used inside metadata driver method to simplify aggregation of data.
  34.      */
  35.     protected $drivers = [];
  37.     /**
  38.      * @param array $objectManager A configured object manager
  39.      *
  40.      * @throws \InvalidArgumentException
  41.      */
  42.     protected function loadMappingInformation(array $objectManager, ContainerBuilder $container)
  43.     {
  44.         if ($objectManager['auto_mapping']) {
  45.             // automatically register bundle mappings
  46.             foreach (array_keys($container->getParameter('kernel.bundles')) as $bundle) {
  47.                 if (!isset($objectManager['mappings'][$bundle])) {
  48.                     $objectManager['mappings'][$bundle] = [
  49.                         'mapping' => true,
  50.                         'is_bundle' => true,
  51.                     ];
  52.                 }
  53.             }
  54.         }
  56.         foreach ($objectManager['mappings'] as $mappingName => $mappingConfig) {
  57.             if (null !== $mappingConfig && false === $mappingConfig['mapping']) {
  58.                 continue;
  59.             }
  61.             $mappingConfig = array_replace([
  62.                 'dir' => false,
  63.                 'type' => false,
  64.                 'prefix' => false,
  65.             ], (array) $mappingConfig);
  67.             $mappingConfig['dir'] = $container->getParameterBag()->resolveValue($mappingConfig['dir']);
  68.             // a bundle configuration is detected by realizing that the specified dir is not absolute and existing
  69.             if (!isset($mappingConfig['is_bundle'])) {
  70.                 $mappingConfig['is_bundle'] = !is_dir($mappingConfig['dir']);
  71.             }
  73.             if ($mappingConfig['is_bundle']) {
  74.                 $bundle = null;
  75.                 foreach ($container->getParameter('kernel.bundles') as $name => $class) {
  76.                     if ($mappingName === $name) {
  77.                         $bundle = new \ReflectionClass($class);
  79.                         break;
  80.                     }
  81.                 }
  83.                 if (null === $bundle) {
  84.                     throw new \InvalidArgumentException(sprintf('Bundle "%s" does not exist or it is not enabled.', $mappingName));
  85.                 }
  87.                 $mappingConfig = $this->getMappingDriverBundleConfigDefaults($mappingConfig, $bundle, $container);
  88.                 if (!$mappingConfig) {
  89.                     continue;
  90.                 }
  91.             }
  93.             $this->assertValidMappingConfiguration($mappingConfig, $objectManager['name']);
  94.             $this->setMappingDriverConfig($mappingConfig, $mappingName);
  95.             $this->setMappingDriverAlias($mappingConfig, $mappingName);
  96.         }
  97.     }
  99.     /**
  100.      * Register the alias for this mapping driver.
  101.      *
  102.      * Aliases can be used in the Query languages of all the Doctrine object managers to simplify writing tasks.
  103.      *
  104.      * @param array  $mappingConfig
  105.      * @param string $mappingName
  106.      */
  107.     protected function setMappingDriverAlias($mappingConfig, $mappingName)
  108.     {
  109.         if (isset($mappingConfig['alias'])) {
  110.             $this->aliasMap[$mappingConfig['alias']] = $mappingConfig['prefix'];
  111.         } else {
  112.             $this->aliasMap[$mappingName] = $mappingConfig['prefix'];
  113.         }
  114.     }
  116.     /**
  117.      * Register the mapping driver configuration for later use with the object managers metadata driver chain.
  118.      *
  119.      * @param string $mappingName
  120.      *
  121.      * @throws \InvalidArgumentException
  122.      */
  123.     protected function setMappingDriverConfig(array $mappingConfig, $mappingName)
  124.     {
  125.         $mappingDirectory = $mappingConfig['dir'];
  126.         if (!is_dir($mappingDirectory)) {
  127.             throw new \InvalidArgumentException(sprintf('Invalid Doctrine mapping path given. Cannot load Doctrine mapping/bundle named "%s".', $mappingName));
  128.         }
  130.         $this->drivers[$mappingConfig['type']][$mappingConfig['prefix']] = realpath($mappingDirectory) ?: $mappingDirectory;
  131.     }
  133.     /**
  134.      * If this is a bundle controlled mapping all the missing information can be autodetected by this method.
  135.      *
  136.      * Returns false when autodetection failed, an array of the completed information otherwise.
  137.      *
  138.      * @return array|false
  139.      */
  140.     protected function getMappingDriverBundleConfigDefaults(array $bundleConfig, \ReflectionClass $bundle, ContainerBuilder $container)
  141.     {
  142.         $bundleDir = \dirname($bundle->getFileName());
  144.         if (!$bundleConfig['type']) {
  145.             $bundleConfig['type'] = $this->detectMetadataDriver($bundleDir, $container);
  146.         }
  148.         if (!$bundleConfig['type']) {
  149.             // skip this bundle, no mapping information was found.
  150.             return false;
  151.         }
  153.         if (!$bundleConfig['dir']) {
  154.             if (\in_array($bundleConfig['type'], ['annotation', 'staticphp'])) {
  155.                 $bundleConfig['dir'] = $bundleDir.'/'.$this->getMappingObjectDefaultName();
  156.             } else {
  157.                 $bundleConfig['dir'] = $bundleDir.'/'.$this->getMappingResourceConfigDirectory();
  158.             }
  159.         } else {
  160.             $bundleConfig['dir'] = $bundleDir.'/'.$bundleConfig['dir'];
  161.         }
  163.         if (!$bundleConfig['prefix']) {
  164.             $bundleConfig['prefix'] = $bundle->getNamespaceName().'\\'.$this->getMappingObjectDefaultName();
  165.         }
  167.         return $bundleConfig;
  168.     }
  170.     /**
  171.      * Register all the collected mapping information with the object manager by registering the appropriate mapping drivers.
  172.      *
  173.      * @param array $objectManager
  174.      */
  175.     protected function registerMappingDrivers($objectManager, ContainerBuilder $container)
  176.     {
  177.         // configure metadata driver for each bundle based on the type of mapping files found
  178.         if ($container->hasDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'))) {
  179.             $chainDriverDef = $container->getDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'));
  180.         } else {
  181.             $chainDriverDef = new Definition($this->getMetadataDriverClass('driver_chain'));
  182.             $chainDriverDef->setPublic(false);
  183.         }
  185.         foreach ($this->drivers as $driverType => $driverPaths) {
  186.             $mappingService = $this->getObjectManagerElementName($objectManager['name'].'_'.$driverType.'_metadata_driver');
  187.             if ($container->hasDefinition($mappingService)) {
  188.                 $mappingDriverDef = $container->getDefinition($mappingService);
  189.                 $args = $mappingDriverDef->getArguments();
  190.                 if ('annotation' == $driverType) {
  191.                     $args[1] = array_merge(array_values($driverPaths), $args[1]);
  192.                 } else {
  193.                     $args[0] = array_merge(array_values($driverPaths), $args[0]);
  194.                 }
  195.                 $mappingDriverDef->setArguments($args);
  196.             } elseif ('annotation' == $driverType) {
  197.                 $mappingDriverDef = new Definition($this->getMetadataDriverClass($driverType), [
  198.                     new Reference($this->getObjectManagerElementName('metadata.annotation_reader')),
  199.                     array_values($driverPaths),
  200.                 ]);
  201.             } else {
  202.                 $mappingDriverDef = new Definition($this->getMetadataDriverClass($driverType), [
  203.                     array_values($driverPaths),
  204.                 ]);
  205.             }
  206.             $mappingDriverDef->setPublic(false);
  207.             if (false !== strpos($mappingDriverDef->getClass(), 'yml') || false !== strpos($mappingDriverDef->getClass(), 'xml')) {
  208.                 $mappingDriverDef->setArguments([array_flip($driverPaths)]);
  209.                 $mappingDriverDef->addMethodCall('setGlobalBasename', ['mapping']);
  210.             }
  212.             $container->setDefinition($mappingService, $mappingDriverDef);
  214.             foreach ($driverPaths as $prefix => $driverPath) {
  215.                 $chainDriverDef->addMethodCall('addDriver', [new Reference($mappingService), $prefix]);
  216.             }
  217.         }
  219.         $container->setDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'), $chainDriverDef);
  220.     }
  222.     /**
  223.      * Assertion if the specified mapping information is valid.
  224.      *
  225.      * @param string $objectManagerName
  226.      *
  227.      * @throws \InvalidArgumentException
  228.      */
  229.     protected function assertValidMappingConfiguration(array $mappingConfig, $objectManagerName)
  230.     {
  231.         if (!$mappingConfig['type'] || !$mappingConfig['dir'] || !$mappingConfig['prefix']) {
  232.             throw new \InvalidArgumentException(sprintf('Mapping definitions for Doctrine manager "%s" require at least the "type", "dir" and "prefix" options.', $objectManagerName));
  233.         }
  235.         if (!is_dir($mappingConfig['dir'])) {
  236.             throw new \InvalidArgumentException(sprintf('Specified non-existing directory "%s" as Doctrine mapping source.', $mappingConfig['dir']));
  237.         }
  239.         if (!\in_array($mappingConfig['type'], ['xml', 'yml', 'annotation', 'php', 'staticphp'])) {
  240.             throw new \InvalidArgumentException(sprintf('Can only configure "xml", "yml", "annotation", "php" or '.
  241.                 '"staticphp" through the DoctrineBundle. Use your own bundle to configure other metadata drivers. '.
  242.                 'You can register them by adding a new driver to the '.
  243.                 '"%s" service definition.', $this->getObjectManagerElementName($objectManagerName.'_metadata_driver')
  244.             ));
  245.         }
  246.     }
  248.     /**
  249.      * Detects what metadata driver to use for the supplied directory.
  250.      *
  251.      * @param string $dir A directory path
  252.      *
  253.      * @return string|null A metadata driver short name, if one can be detected
  254.      */
  255.     protected function detectMetadataDriver($dir, ContainerBuilder $container)
  256.     {
  257.         $configPath = $this->getMappingResourceConfigDirectory();
  258.         $extension = $this->getMappingResourceExtension();
  260.         if (glob($dir.'/'.$configPath.'/*.'.$extension.'.xml', GLOB_NOSORT)) {
  261.             $driver = 'xml';
  262.         } elseif (glob($dir.'/'.$configPath.'/*.'.$extension.'.yml', GLOB_NOSORT)) {
  263.             $driver = 'yml';
  264.         } elseif (glob($dir.'/'.$configPath.'/*.'.$extension.'.php', GLOB_NOSORT)) {
  265.             $driver = 'php';
  266.         } else {
  267.             // add the closest existing directory as a resource
  268.             $resource = $dir.'/'.$configPath;
  269.             while (!is_dir($resource)) {
  270.                 $resource = \dirname($resource);
  271.             }
  272.             $container->fileExists($resource, false);
  274.             return $container->fileExists($dir.'/'.$this->getMappingObjectDefaultName(), false) ? 'annotation' : null;
  275.         }
  276.         $container->fileExists($dir.'/'.$configPath, false);
  278.         return $driver;
  279.     }
  281.     /**
  282.      * Loads a configured object manager metadata, query or result cache driver.
  283.      *
  284.      * @param array  $objectManager A configured object manager
  285.      * @param string $cacheName
  286.      *
  287.      * @throws \InvalidArgumentException in case of unknown driver type
  288.      */
  289.     protected function loadObjectManagerCacheDriver(array $objectManager, ContainerBuilder $container, $cacheName)
  290.     {
  291.         $this->loadCacheDriver($cacheName, $objectManager['name'], $objectManager[$cacheName.'_driver'], $container);
  292.     }
  294.     /**
  295.      * Loads a cache driver.
  296.      *
  297.      * @param string $cacheName         The cache driver name
  298.      * @param string $objectManagerName The object manager name
  299.      * @param array  $cacheDriver       The cache driver mapping
  300.      *
  301.      * @return string
  302.      *
  303.      * @throws \InvalidArgumentException
  304.      */
  305.     protected function loadCacheDriver($cacheName, $objectManagerName, array $cacheDriver, ContainerBuilder $container)
  306.     {
  307.         $cacheDriverServiceId = $this->getObjectManagerElementName($objectManagerName.'_'.$cacheName);
  309.         switch ($cacheDriver['type']) {
  310.             case 'service':
  311.                 $container->setAlias($cacheDriverServiceId, new Alias($cacheDriver['id'], false));
  313.                 return $cacheDriverServiceId;
  314.             case 'memcached':
  315.                 $memcachedClass = !empty($cacheDriver['class']) ? $cacheDriver['class'] : '%'.$this->getObjectManagerElementName('cache.memcached.class').'%';
  316.                 $memcachedInstanceClass = !empty($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%'.$this->getObjectManagerElementName('cache.memcached_instance.class').'%';
  317.                 $memcachedHost = !empty($cacheDriver['host']) ? $cacheDriver['host'] : '%'.$this->getObjectManagerElementName('cache.memcached_host').'%';
  318.                 $memcachedPort = !empty($cacheDriver['port']) ? $cacheDriver['port'] : '%'.$this->getObjectManagerElementName('cache.memcached_port').'%';
  319.                 $cacheDef = new Definition($memcachedClass);
  320.                 $memcachedInstance = new Definition($memcachedInstanceClass);
  321.                 $memcachedInstance->setPrivate(true);
  322.                 $memcachedInstance->addMethodCall('addServer', [
  323.                     $memcachedHost, $memcachedPort,
  324.                 ]);
  325.                 $container->setDefinition($this->getObjectManagerElementName(sprintf('%s_memcached_instance', $objectManagerName)), $memcachedInstance);
  326.                 $cacheDef->addMethodCall('setMemcached', [new Reference($this->getObjectManagerElementName(sprintf('%s_memcached_instance', $objectManagerName)))]);
  327.                 break;
  328.              case 'redis':
  329.                 $redisClass = !empty($cacheDriver['class']) ? $cacheDriver['class'] : '%'.$this->getObjectManagerElementName('cache.redis.class').'%';
  330.                 $redisInstanceClass = !empty($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%'.$this->getObjectManagerElementName('cache.redis_instance.class').'%';
  331.                 $redisHost = !empty($cacheDriver['host']) ? $cacheDriver['host'] : '%'.$this->getObjectManagerElementName('cache.redis_host').'%';
  332.                 $redisPort = !empty($cacheDriver['port']) ? $cacheDriver['port'] : '%'.$this->getObjectManagerElementName('cache.redis_port').'%';
  333.                 $cacheDef = new Definition($redisClass);
  334.                 $redisInstance = new Definition($redisInstanceClass);
  335.                 $redisInstance->setPrivate(true);
  336.                 $redisInstance->addMethodCall('connect', [
  337.                     $redisHost, $redisPort,
  338.                 ]);
  339.                 $container->setDefinition($this->getObjectManagerElementName(sprintf('%s_redis_instance', $objectManagerName)), $redisInstance);
  340.                 $cacheDef->addMethodCall('setRedis', [new Reference($this->getObjectManagerElementName(sprintf('%s_redis_instance', $objectManagerName)))]);
  341.                 break;
  342.             case 'apc':
  343.             case 'apcu':
  344.             case 'array':
  345.             case 'xcache':
  346.             case 'wincache':
  347.             case 'zenddata':
  348.                 $cacheDef = new Definition('%'.$this->getObjectManagerElementName(sprintf('cache.%s.class', $cacheDriver['type'])).'%');
  349.                 break;
  350.             default:
  351.                 throw new \InvalidArgumentException(sprintf('"%s" is an unrecognized Doctrine cache driver.', $cacheDriver['type']));
  352.         }
  354.         $cacheDef->setPublic(false);
  356.         if (!isset($cacheDriver['namespace'])) {
  357.             // generate a unique namespace for the given application
  358.             if ($container->hasParameter('cache.prefix.seed')) {
  359.                 $seed = '.'.$container->getParameterBag()->resolveValue($container->getParameter('cache.prefix.seed'));
  360.             } else {
  361.                 $seed = '_'.$container->getParameter('kernel.project_dir');
  362.             }
  363.             $seed .= '.'.$container->getParameter('kernel.container_class');
  364.             $namespace = 'sf_'.$this->getMappingResourceExtension().'_'.$objectManagerName.'_'.ContainerBuilder::hash($seed);
  366.             $cacheDriver['namespace'] = $namespace;
  367.         }
  369.         $cacheDef->addMethodCall('setNamespace', [$cacheDriver['namespace']]);
  371.         $container->setDefinition($cacheDriverServiceId, $cacheDef);
  373.         return $cacheDriverServiceId;
  374.     }
  376.     /**
  377.      * Returns a modified version of $managerConfigs.
  378.      *
  379.      * The manager called $autoMappedManager will map all bundles that are not mapped by other managers.
  380.      *
  381.      * @return array The modified version of $managerConfigs
  382.      */
  383.     protected function fixManagersAutoMappings(array $managerConfigs, array $bundles)
  384.     {
  385.         if ($autoMappedManager = $this->validateAutoMapping($managerConfigs)) {
  386.             foreach (array_keys($bundles) as $bundle) {
  387.                 foreach ($managerConfigs as $manager) {
  388.                     if (isset($manager['mappings'][$bundle])) {
  389.                         continue 2;
  390.                     }
  391.                 }
  392.                 $managerConfigs[$autoMappedManager]['mappings'][$bundle] = [
  393.                     'mapping' => true,
  394.                     'is_bundle' => true,
  395.                 ];
  396.             }
  397.             $managerConfigs[$autoMappedManager]['auto_mapping'] = false;
  398.         }
  400.         return $managerConfigs;
  401.     }
  403.     /**
  404.      * Prefixes the relative dependency injection container path with the object manager prefix.
  405.      *
  406.      * @example $name is 'entity_manager' then the result would be 'doctrine.orm.entity_manager'
  407.      *
  408.      * @param string $name
  409.      *
  410.      * @return string
  411.      */
  412.     abstract protected function getObjectManagerElementName($name);
  414.     /**
  415.      * Noun that describes the mapped objects such as Entity or Document.
  416.      *
  417.      * Will be used for autodetection of persistent objects directory.
  418.      *
  419.      * @return string
  420.      */
  421.     abstract protected function getMappingObjectDefaultName();
  423.     /**
  424.      * Relative path from the bundle root to the directory where mapping files reside.
  425.      *
  426.      * @return string
  427.      */
  428.     abstract protected function getMappingResourceConfigDirectory();
  430.     /**
  431.      * Extension used by the mapping files.
  432.      *
  433.      * @return string
  434.      */
  435.     abstract protected function getMappingResourceExtension();
  437.     /**
  438.      * The class name used by the various mapping drivers.
  439.      */
  440.     protected function getMetadataDriverClass(string $driverType): string
  441.     {
  442.         @trigger_error(sprintf('Not declaring the "%s" method in class "%s" is deprecated since Symfony 4.4. This method will be abstract in Symfony 5.0.', __METHOD__, static::class), E_USER_DEPRECATED);
  444.         return '%'.$this->getObjectManagerElementName('metadata.'.$driverType.'.class%');
  445.     }
  447.     /**
  448.      * Search for a manager that is declared as 'auto_mapping' = true.
  449.      *
  450.      * @throws \LogicException
  451.      */
  452.     private function validateAutoMapping(array $managerConfigs): ?string
  453.     {
  454.         $autoMappedManager = null;
  455.         foreach ($managerConfigs as $name => $manager) {
  456.             if (!$manager['auto_mapping']) {
  457.                 continue;
  458.             }
  460.             if (null !== $autoMappedManager) {
  461.                 throw new \LogicException(sprintf('You cannot enable "auto_mapping" on more than one manager at the same time (found in "%s" and %s").', $autoMappedManager, $name));
  462.             }
  464.             $autoMappedManager = $name;
  465.         }
  467.         return $autoMappedManager;
  468.     }
  469. }