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

  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\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 <kontakt@beberlei.de>
  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.                 $bundleMetadata = null;
  77.                 foreach ($container->getParameter('kernel.bundles') as $name => $class) {
  78.                     if ($mappingName === $name) {
  79.                         $bundle = new \ReflectionClass($class);
  80.                         $bundleMetadata = $container->getParameter('kernel.bundles_metadata')[$name];
  82.                         break;
  83.                     }
  84.                 }
  86.                 if (null === $bundle) {
  87.                     throw new \InvalidArgumentException(sprintf('Bundle "%s" does not exist or it is not enabled.', $mappingName));
  88.                 }
  90.                 $mappingConfig = $this->getMappingDriverBundleConfigDefaults($mappingConfig, $bundle, $container, $bundleMetadata['path']);
  91.                 if (!$mappingConfig) {
  92.                     continue;
  93.                 }
  94.             } elseif (!$mappingConfig['type']) {
  95.                 $mappingConfig['type'] = $this->detectMappingType($mappingConfig['dir'], $container);
  96.             }
  98.             $this->assertValidMappingConfiguration($mappingConfig, $objectManager['name']);
  99.             $this->setMappingDriverConfig($mappingConfig, $mappingName);
  100.             $this->setMappingDriverAlias($mappingConfig, $mappingName);
  101.         }
  102.     }
  104.     /**
  105.      * Register the alias for this mapping driver.
  106.      *
  107.      * Aliases can be used in the Query languages of all the Doctrine object managers to simplify writing tasks.
  108.      */
  109.     protected function setMappingDriverAlias(array $mappingConfig, string $mappingName)
  110.     {
  111.         if (isset($mappingConfig['alias'])) {
  112.             $this->aliasMap[$mappingConfig['alias']] = $mappingConfig['prefix'];
  113.         } else {
  114.             $this->aliasMap[$mappingName] = $mappingConfig['prefix'];
  115.         }
  116.     }
  118.     /**
  119.      * Register the mapping driver configuration for later use with the object managers metadata driver chain.
  120.      *
  121.      * @throws \InvalidArgumentException
  122.      */
  123.     protected function setMappingDriverConfig(array $mappingConfig, string $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.     protected function getMappingDriverBundleConfigDefaults(array $bundleConfig, \ReflectionClass $bundle, ContainerBuilder $container, string $bundleDir = null): array|false
  139.     {
  140.         $bundleClassDir = \dirname($bundle->getFileName());
  141.         $bundleDir ??= $bundleClassDir;
  143.         if (!$bundleConfig['type']) {
  144.             $bundleConfig['type'] = $this->detectMetadataDriver($bundleDir, $container);
  146.             if (!$bundleConfig['type'] && $bundleDir !== $bundleClassDir) {
  147.                 $bundleConfig['type'] = $this->detectMetadataDriver($bundleClassDir, $container);
  148.             }
  149.         }
  151.         if (!$bundleConfig['type']) {
  152.             // skip this bundle, no mapping information was found.
  153.             return false;
  154.         }
  156.         if (!$bundleConfig['dir']) {
  157.             if (\in_array($bundleConfig['type'], ['annotation', 'staticphp', 'attribute'])) {
  158.                 $bundleConfig['dir'] = $bundleClassDir.'/'.$this->getMappingObjectDefaultName();
  159.             } else {
  160.                 $bundleConfig['dir'] = $bundleDir.'/'.$this->getMappingResourceConfigDirectory($bundleDir);
  161.             }
  162.         } else {
  163.             $bundleConfig['dir'] = $bundleDir.'/'.$bundleConfig['dir'];
  164.         }
  166.         if (!$bundleConfig['prefix']) {
  167.             $bundleConfig['prefix'] = $bundle->getNamespaceName().'\\'.$this->getMappingObjectDefaultName();
  168.         }
  170.         return $bundleConfig;
  171.     }
  173.     /**
  174.      * Register all the collected mapping information with the object manager by registering the appropriate mapping drivers.
  175.      */
  176.     protected function registerMappingDrivers(array $objectManager, ContainerBuilder $container)
  177.     {
  178.         // configure metadata driver for each bundle based on the type of mapping files found
  179.         if ($container->hasDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'))) {
  180.             $chainDriverDef = $container->getDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'));
  181.         } else {
  182.             $chainDriverDef = new Definition($this->getMetadataDriverClass('driver_chain'));
  183.             $chainDriverDef->setPublic(false);
  184.         }
  186.         foreach ($this->drivers as $driverType => $driverPaths) {
  187.             $mappingService = $this->getObjectManagerElementName($objectManager['name'].'_'.$driverType.'_metadata_driver');
  188.             if ($container->hasDefinition($mappingService)) {
  189.                 $mappingDriverDef = $container->getDefinition($mappingService);
  190.                 $args = $mappingDriverDef->getArguments();
  191.                 if ('annotation' == $driverType) {
  192.                     $args[1] = array_merge(array_values($driverPaths), $args[1]);
  193.                 } else {
  194.                     $args[0] = array_merge(array_values($driverPaths), $args[0]);
  195.                 }
  196.                 $mappingDriverDef->setArguments($args);
  197.             } elseif ('attribute' === $driverType) {
  198.                 $mappingDriverDef = new Definition($this->getMetadataDriverClass($driverType), [
  199.                     array_values($driverPaths),
  200.                 ]);
  201.             } elseif ('annotation' == $driverType) {
  202.                 $mappingDriverDef = new Definition($this->getMetadataDriverClass($driverType), [
  203.                     new Reference($this->getObjectManagerElementName('metadata.annotation_reader')),
  204.                     array_values($driverPaths),
  205.                 ]);
  206.             } else {
  207.                 $mappingDriverDef = new Definition($this->getMetadataDriverClass($driverType), [
  208.                     array_values($driverPaths),
  209.                 ]);
  210.             }
  211.             $mappingDriverDef->setPublic(false);
  212.             if (str_contains($mappingDriverDef->getClass(), 'yml') || str_contains($mappingDriverDef->getClass(), 'xml')) {
  213.                 $mappingDriverDef->setArguments([array_flip($driverPaths)]);
  214.                 $mappingDriverDef->addMethodCall('setGlobalBasename', ['mapping']);
  215.             }
  217.             $container->setDefinition($mappingService, $mappingDriverDef);
  219.             foreach ($driverPaths as $prefix => $driverPath) {
  220.                 $chainDriverDef->addMethodCall('addDriver', [new Reference($mappingService), $prefix]);
  221.             }
  222.         }
  224.         $container->setDefinition($this->getObjectManagerElementName($objectManager['name'].'_metadata_driver'), $chainDriverDef);
  225.     }
  227.     /**
  228.      * Assertion if the specified mapping information is valid.
  229.      *
  230.      * @throws \InvalidArgumentException
  231.      */
  232.     protected function assertValidMappingConfiguration(array $mappingConfig, string $objectManagerName)
  233.     {
  234.         if (!$mappingConfig['type'] || !$mappingConfig['dir'] || !$mappingConfig['prefix']) {
  235.             throw new \InvalidArgumentException(sprintf('Mapping definitions for Doctrine manager "%s" require at least the "type", "dir" and "prefix" options.', $objectManagerName));
  236.         }
  238.         if (!is_dir($mappingConfig['dir'])) {
  239.             throw new \InvalidArgumentException(sprintf('Specified non-existing directory "%s" as Doctrine mapping source.', $mappingConfig['dir']));
  240.         }
  242.         if (!\in_array($mappingConfig['type'], ['xml', 'yml', 'annotation', 'php', 'staticphp', 'attribute'])) {
  243.             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')));
  244.         }
  245.     }
  247.     /**
  248.      * Detects what metadata driver to use for the supplied directory.
  249.      */
  250.     protected function detectMetadataDriver(string $dir, ContainerBuilder $container): ?string
  251.     {
  252.         $configPath = $this->getMappingResourceConfigDirectory($dir);
  253.         $extension = $this->getMappingResourceExtension();
  255.         if (glob($dir.'/'.$configPath.'/*.'.$extension.'.xml', \GLOB_NOSORT)) {
  256.             $driver = 'xml';
  257.         } elseif (glob($dir.'/'.$configPath.'/*.'.$extension.'.yml', \GLOB_NOSORT)) {
  258.             $driver = 'yml';
  259.         } elseif (glob($dir.'/'.$configPath.'/*.'.$extension.'.php', \GLOB_NOSORT)) {
  260.             $driver = 'php';
  261.         } else {
  262.             // add the closest existing directory as a resource
  263.             $resource = $dir.'/'.$configPath;
  264.             while (!is_dir($resource)) {
  265.                 $resource = \dirname($resource);
  266.             }
  267.             $container->fileExists($resource, false);
  269.             if ($container->fileExists($discoveryPath = $dir.'/'.$this->getMappingObjectDefaultName(), false)) {
  270.                 return $this->detectMappingType($discoveryPath, $container);
  271.             }
  273.             return null;
  274.         }
  275.         $container->fileExists($dir.'/'.$configPath, false);
  277.         return $driver;
  278.     }
  280.     /**
  281.      * Detects what mapping type to use for the supplied directory.
  282.      *
  283.      * @return string A mapping type 'attribute' or 'annotation'
  284.      */
  285.     private function detectMappingType(string $directory, ContainerBuilder $container): string
  286.     {
  287.         $type = 'attribute';
  289.         $glob = new GlobResource($directory, '*', true);
  290.         $container->addResource($glob);
  292.         $quotedMappingObjectName = preg_quote($this->getMappingObjectDefaultName(), '/');
  294.         foreach ($glob as $file) {
  295.             $content = file_get_contents($file);
  297.             if (
  298.                 preg_match('/^#\[.*'.$quotedMappingObjectName.'\b/m', $content) ||
  299.                 preg_match('/^#\[.*Embeddable\b/m', $content)
  300.             ) {
  301.                 break;
  302.             }
  303.             if (
  304.                 preg_match('/^(?: \*|\/\*\*) @.*'.$quotedMappingObjectName.'\b/m', $content) ||
  305.                 preg_match('/^(?: \*|\/\*\*) @.*Embeddable\b/m', $content)
  306.             ) {
  307.                 $type = 'annotation';
  308.                 break;
  309.             }
  310.         }
  312.         return $type;
  313.     }
  315.     /**
  316.      * Loads a configured object manager metadata, query or result cache driver.
  317.      *
  318.      * @throws \InvalidArgumentException in case of unknown driver type
  319.      */
  320.     protected function loadObjectManagerCacheDriver(array $objectManager, ContainerBuilder $container, string $cacheName)
  321.     {
  322.         $this->loadCacheDriver($cacheName, $objectManager['name'], $objectManager[$cacheName.'_driver'], $container);
  323.     }
  325.     /**
  326.      * Loads a cache driver.
  327.      *
  328.      * @throws \InvalidArgumentException
  329.      */
  330.     protected function loadCacheDriver(string $cacheName, string $objectManagerName, array $cacheDriver, ContainerBuilder $container): string
  331.     {
  332.         $cacheDriverServiceId = $this->getObjectManagerElementName($objectManagerName.'_'.$cacheName);
  334.         switch ($cacheDriver['type']) {
  335.             case 'service':
  336.                 $container->setAlias($cacheDriverServiceId, new Alias($cacheDriver['id'], false));
  338.                 return $cacheDriverServiceId;
  339.             case 'memcached':
  340.                 $memcachedClass = !empty($cacheDriver['class']) ? $cacheDriver['class'] : '%'.$this->getObjectManagerElementName('cache.memcached.class').'%';
  341.                 $memcachedInstanceClass = !empty($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%'.$this->getObjectManagerElementName('cache.memcached_instance.class').'%';
  342.                 $memcachedHost = !empty($cacheDriver['host']) ? $cacheDriver['host'] : '%'.$this->getObjectManagerElementName('cache.memcached_host').'%';
  343.                 $memcachedPort = !empty($cacheDriver['port']) ? $cacheDriver['port'] : '%'.$this->getObjectManagerElementName('cache.memcached_port').'%';
  344.                 $cacheDef = new Definition($memcachedClass);
  345.                 $memcachedInstance = new Definition($memcachedInstanceClass);
  346.                 $memcachedInstance->addMethodCall('addServer', [
  347.                     $memcachedHost, $memcachedPort,
  348.                 ]);
  349.                 $container->setDefinition($this->getObjectManagerElementName(sprintf('%s_memcached_instance', $objectManagerName)), $memcachedInstance);
  350.                 $cacheDef->addMethodCall('setMemcached', [new Reference($this->getObjectManagerElementName(sprintf('%s_memcached_instance', $objectManagerName)))]);
  351.                 break;
  352.             case 'redis':
  353.                 $redisClass = !empty($cacheDriver['class']) ? $cacheDriver['class'] : '%'.$this->getObjectManagerElementName('cache.redis.class').'%';
  354.                 $redisInstanceClass = !empty($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%'.$this->getObjectManagerElementName('cache.redis_instance.class').'%';
  355.                 $redisHost = !empty($cacheDriver['host']) ? $cacheDriver['host'] : '%'.$this->getObjectManagerElementName('cache.redis_host').'%';
  356.                 $redisPort = !empty($cacheDriver['port']) ? $cacheDriver['port'] : '%'.$this->getObjectManagerElementName('cache.redis_port').'%';
  357.                 $cacheDef = new Definition($redisClass);
  358.                 $redisInstance = new Definition($redisInstanceClass);
  359.                 $redisInstance->addMethodCall('connect', [
  360.                     $redisHost, $redisPort,
  361.                 ]);
  362.                 $container->setDefinition($this->getObjectManagerElementName(sprintf('%s_redis_instance', $objectManagerName)), $redisInstance);
  363.                 $cacheDef->addMethodCall('setRedis', [new Reference($this->getObjectManagerElementName(sprintf('%s_redis_instance', $objectManagerName)))]);
  364.                 break;
  365.             case 'apc':
  366.             case 'apcu':
  367.             case 'array':
  368.             case 'xcache':
  369.             case 'wincache':
  370.             case 'zenddata':
  371.                 $cacheDef = new Definition('%'.$this->getObjectManagerElementName(sprintf('cache.%s.class', $cacheDriver['type'])).'%');
  372.                 break;
  373.             default:
  374.                 throw new \InvalidArgumentException(sprintf('"%s" is an unrecognized Doctrine cache driver.', $cacheDriver['type']));
  375.         }
  377.         $cacheDef->setPublic(false);
  379.         if (!isset($cacheDriver['namespace'])) {
  380.             // generate a unique namespace for the given application
  381.             if ($container->hasParameter('cache.prefix.seed')) {
  382.                 $seed = $container->getParameterBag()->resolveValue($container->getParameter('cache.prefix.seed'));
  383.             } else {
  384.                 $seed = '_'.$container->getParameter('kernel.project_dir');
  385.                 $seed .= '.'.$container->getParameter('kernel.container_class');
  386.             }
  388.             $namespace = 'sf_'.$this->getMappingResourceExtension().'_'.$objectManagerName.'_'.ContainerBuilder::hash($seed);
  390.             $cacheDriver['namespace'] = $namespace;
  391.         }
  393.         $cacheDef->addMethodCall('setNamespace', [$cacheDriver['namespace']]);
  395.         $container->setDefinition($cacheDriverServiceId, $cacheDef);
  397.         return $cacheDriverServiceId;
  398.     }
  400.     /**
  401.      * Returns a modified version of $managerConfigs.
  402.      *
  403.      * The manager called $autoMappedManager will map all bundles that are not mapped by other managers.
  404.      */
  405.     protected function fixManagersAutoMappings(array $managerConfigs, array $bundles): array
  406.     {
  407.         if ($autoMappedManager = $this->validateAutoMapping($managerConfigs)) {
  408.             foreach (array_keys($bundles) as $bundle) {
  409.                 foreach ($managerConfigs as $manager) {
  410.                     if (isset($manager['mappings'][$bundle])) {
  411.                         continue 2;
  412.                     }
  413.                 }
  414.                 $managerConfigs[$autoMappedManager]['mappings'][$bundle] = [
  415.                     'mapping' => true,
  416.                     'is_bundle' => true,
  417.                 ];
  418.             }
  419.             $managerConfigs[$autoMappedManager]['auto_mapping'] = false;
  420.         }
  422.         return $managerConfigs;
  423.     }
  425.     /**
  426.      * Prefixes the relative dependency injection container path with the object manager prefix.
  427.      *
  428.      * @example $name is 'entity_manager' then the result would be 'doctrine.orm.entity_manager'
  429.      */
  430.     abstract protected function getObjectManagerElementName(string $name): string;
  432.     /**
  433.      * Noun that describes the mapped objects such as Entity or Document.
  434.      *
  435.      * Will be used for autodetection of persistent objects directory.
  436.      */
  437.     abstract protected function getMappingObjectDefaultName(): string;
  439.     /**
  440.      * Relative path from the bundle root to the directory where mapping files reside.
  441.      */
  442.     abstract protected function getMappingResourceConfigDirectory(string $bundleDir = null): string;
  444.     /**
  445.      * Extension used by the mapping files.
  446.      */
  447.     abstract protected function getMappingResourceExtension(): string;
  449.     /**
  450.      * The class name used by the various mapping drivers.
  451.      */
  452.     abstract protected function getMetadataDriverClass(string $driverType): string;
  454.     /**
  455.      * Search for a manager that is declared as 'auto_mapping' = true.
  456.      *
  457.      * @throws \LogicException
  458.      */
  459.     private function validateAutoMapping(array $managerConfigs): ?string
  460.     {
  461.         $autoMappedManager = null;
  462.         foreach ($managerConfigs as $name => $manager) {
  463.             if (!$manager['auto_mapping']) {
  464.                 continue;
  465.             }
  467.             if (null !== $autoMappedManager) {
  468.                 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));
  469.             }
  471.             $autoMappedManager = $name;
  472.         }
  474.         return $autoMappedManager;
  475.     }
  476. }