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

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