vendor/shopware/core/Framework/Plugin/KernelPluginLoader/KernelPluginLoader.php line 108

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Plugin\KernelPluginLoader;
  5. use Composer\Autoload\ClassLoader;
  6. use Composer\Autoload\ClassMapGenerator;
  7. use Shopware\Core\Framework\Log\Package;
  8. use Shopware\Core\Framework\Parameter\AdditionalBundleParameters;
  9. use Shopware\Core\Framework\Plugin;
  10. use Shopware\Core\Framework\Plugin\Exception\KernelPluginLoaderException;
  11. use Shopware\Core\Framework\Plugin\KernelPluginCollection;
  12. use Symfony\Component\DependencyInjection\ContainerBuilder;
  13. use Symfony\Component\DependencyInjection\Definition;
  14. use Symfony\Component\DependencyInjection\Reference;
  15. use Symfony\Component\HttpKernel\Bundle\Bundle;
  17. #[Package('core')]
  18. abstract class KernelPluginLoader extends Bundle
  19. {
  20.     /**
  21.      * @var array<int, mixed>
  22.      */
  23.     protected $pluginInfos = [];
  25.     private readonly KernelPluginCollection $pluginInstances;
  27.     private readonly string $pluginDir;
  29.     private bool $initialized = false;
  31.     /**
  32.      * @internal
  33.      */
  34.     public function __construct(private readonly ClassLoader $classLoader, ?string $pluginDir = null)
  35.     {
  36.         $this->pluginDir = $pluginDir ?? 'custom/plugins';
  37.         $this->pluginInstances = new KernelPluginCollection();
  38.     }
  40.     final public function getPluginDir(string $projectDir): string
  41.     {
  42.         // absolute path
  43.         if (mb_strpos($this->pluginDir, '/') === 0) {
  44.             return $this->pluginDir;
  45.         }
  47.         return $projectDir . '/' . $this->pluginDir;
  48.     }
  50.     /**
  51.      * @return array<int, mixed>
  52.      * Basic information required for instantiating the plugins
  53.      */
  54.     final public function getPluginInfos(): array
  55.     {
  56.         return $this->pluginInfos;
  57.     }
  59.     /**
  60.      * @final
  61.      * Instances of the plugin bundle classes
  62.      */
  63.     public function getPluginInstances(): KernelPluginCollection
  64.     {
  65.         return $this->pluginInstances;
  66.     }
  68.     /**
  69.      * @param array<string, mixed> $kernelParameters
  70.      * @param array<int, string> $loadedBundles
  71.      *
  72.      * @return \Traversable<Bundle>
  73.      */
  74.     final public function getBundles(array $kernelParameters = [], array $loadedBundles = []): iterable
  75.     {
  76.         if (!$this->initialized) {
  77.             return;
  78.         }
  80.         foreach ($this->pluginInstances->getActives() as $plugin) {
  81.             $copy = new KernelPluginCollection($this->getPluginInstances()->all());
  82.             $additionalBundleParameters = new AdditionalBundleParameters($this->classLoader, $copy, $kernelParameters);
  83.             $additionalBundles = $plugin->getAdditionalBundles($additionalBundleParameters);
  84.             [$preLoaded, $postLoaded] = $this->splitBundlesIntoPreAndPost($additionalBundles);
  86.             foreach ([...\array_values($preLoaded), $plugin, ...\array_values($postLoaded)] as $bundle) {
  87.                 if (!\in_array($bundle->getName(), $loadedBundles, true)) {
  88.                     yield $bundle;
  89.                     $loadedBundles[] = $bundle->getName();
  90.                 }
  91.             }
  92.         }
  94.         if (!\in_array($this->getName(), $loadedBundles, true)) {
  95.             yield $this;
  96.         }
  97.     }
  99.     /**
  100.      * @throws KernelPluginLoaderException
  101.      */
  102.     final public function initializePlugins(string $projectDir): void
  103.     {
  104.         if ($this->initialized) {
  105.             return;
  106.         }
  108.         $this->loadPluginInfos();
  109.         if (empty($this->pluginInfos)) {
  110.             $this->initialized = true;
  112.             return;
  113.         }
  115.         $this->registerPluginNamespaces($projectDir);
  116.         $this->instantiatePlugins($projectDir);
  118.         $this->initialized = true;
  119.     }
  121.     final public function build(ContainerBuilder $container): void
  122.     {
  123.         if (!$this->initialized) {
  124.             return;
  125.         }
  127.         parent::build($container);
  129.         /*
  130.          * Register every plugin in the di container, enable autowire and set public
  131.          */
  132.         foreach ($this->pluginInstances->getActives() as $plugin) {
  133.             $class = $plugin::class;
  135.             $definition = new Definition();
  136.             if ($container->hasDefinition($class)) {
  137.                 $definition = $container->getDefinition($class);
  138.             }
  140.             $definition->setFactory([new Reference(self::class), 'getPluginInstance']);
  141.             $definition->addArgument($class);
  143.             $definition->setAutowired(true);
  144.             $definition->setPublic(true);
  146.             $container->setDefinition($class, $definition);
  147.         }
  148.     }
  150.     final public function getPluginInstance(string $class): ?Plugin
  151.     {
  152.         $plugin = $this->pluginInstances->get($class);
  153.         if (!$plugin || !$plugin->isActive()) {
  154.             return null;
  155.         }
  157.         return $plugin;
  158.     }
  160.     public function getClassLoader(): ClassLoader
  161.     {
  162.         return $this->classLoader;
  163.     }
  165.     abstract protected function loadPluginInfos(): void;
  167.     /**
  168.      * @throws KernelPluginLoaderException
  169.      */
  170.     private function registerPluginNamespaces(string $projectDir): void
  171.     {
  172.         foreach ($this->pluginInfos as $plugin) {
  173.             $pluginName = $plugin['name'] ?? $plugin['baseClass'];
  175.             // plugins managed by composer are already in the classMap
  176.             if ($plugin['managedByComposer']) {
  177.                 continue;
  178.             }
  180.             if (!isset($plugin['autoload'])) {
  181.                 $reason = sprintf(
  182.                     'Unable to register plugin "%s" in autoload. Required property `autoload` missing.',
  183.                     $plugin['baseClass']
  184.                 );
  186.                 throw new KernelPluginLoaderException($pluginName, $reason);
  187.             }
  189.             $psr4 = $plugin['autoload']['psr-4'] ?? [];
  190.             $psr0 = $plugin['autoload']['psr-0'] ?? [];
  192.             if (empty($psr4) && empty($psr0)) {
  193.                 $reason = sprintf(
  194.                     'Unable to register plugin "%s" in autoload. Required property `psr-4` or `psr-0` missing in property autoload.',
  195.                     $plugin['baseClass']
  196.                 );
  198.                 throw new KernelPluginLoaderException($pluginName, $reason);
  199.             }
  201.             foreach ($psr4 as $namespace => $paths) {
  202.                 if (\is_string($paths)) {
  203.                     $paths = [$paths];
  204.                 }
  205.                 $mappedPaths = $this->mapPsrPaths($pluginName, $paths, $projectDir, $plugin['path']);
  206.                 $this->classLoader->addPsr4($namespace, $mappedPaths);
  207.                 if ($this->classLoader->isClassMapAuthoritative()) {
  208.                     foreach ($mappedPaths as $mappedPath) {
  209.                         $this->classLoader->addClassMap(ClassMapGenerator::createMap($mappedPath));
  210.                     }
  211.                 }
  212.             }
  214.             foreach ($psr0 as $namespace => $paths) {
  215.                 if (\is_string($paths)) {
  216.                     $paths = [$paths];
  217.                 }
  218.                 $mappedPaths = $this->mapPsrPaths($pluginName, $paths, $projectDir, $plugin['path']);
  220.                 $this->classLoader->add($namespace, $mappedPaths);
  221.                 if ($this->classLoader->isClassMapAuthoritative()) {
  222.                     foreach ($mappedPaths as $mappedPath) {
  223.                         $this->classLoader->addClassMap(ClassMapGenerator::createMap($mappedPath));
  224.                     }
  225.                 }
  226.             }
  227.         }
  228.     }
  230.     /**
  231.      * @param array<string> $psr
  232.      *
  233.      * @throws KernelPluginLoaderException
  234.      *
  235.      * @return array<string>
  236.      */
  237.     private function mapPsrPaths(string $plugin, array $psr, string $projectDir, string $pluginRootPath): array
  238.     {
  239.         $mappedPaths = [];
  241.         $absolutePluginRootPath = $this->getAbsolutePluginRootPath($projectDir, $pluginRootPath);
  243.         if (mb_strpos($absolutePluginRootPath, $projectDir) !== 0) {
  244.             throw new KernelPluginLoaderException(
  245.                 $plugin,
  246.                 sprintf('Plugin dir %s needs to be a sub-directory of the project dir %s', $pluginRootPath, $projectDir)
  247.             );
  248.         }
  250.         foreach ($psr as $path) {
  251.             $mappedPaths[] = $absolutePluginRootPath . '/' . $path;
  252.         }
  254.         return $mappedPaths;
  255.     }
  257.     private function getAbsolutePluginRootPath(string $projectDir, string $pluginRootPath): string
  258.     {
  259.         // is relative path
  260.         if (mb_strpos($pluginRootPath, '/') !== 0) {
  261.             $pluginRootPath = $projectDir . '/' . $pluginRootPath;
  262.         }
  264.         return $pluginRootPath;
  265.     }
  267.     /**
  268.      * @throws KernelPluginLoaderException
  269.      */
  270.     private function instantiatePlugins(string $projectDir): void
  271.     {
  272.         foreach ($this->pluginInfos as $pluginData) {
  273.             $className = $pluginData['baseClass'];
  275.             $pluginClassFilePath = $this->classLoader->findFile($className);
  276.             if (!class_exists($className) || !$pluginClassFilePath || !file_exists($pluginClassFilePath)) {
  277.                 continue;
  278.             }
  280.             /** @var Plugin $plugin */
  281.             $plugin = new $className((bool) $pluginData['active'], $pluginData['path'], $projectDir);
  283.             if (!$plugin instanceof Plugin) {
  284.                 $reason = sprintf('Plugin class "%s" must extend "%s"', $plugin::class, Plugin::class);
  286.                 throw new KernelPluginLoaderException($pluginData['name'], $reason);
  287.             }
  289.             $this->pluginInstances->add($plugin);
  290.         }
  291.     }
  293.     /**
  294.      * @param Bundle[] $bundles
  295.      *
  296.      * @return array<Bundle[]>
  297.      */
  298.     private function splitBundlesIntoPreAndPost(array $bundles): array
  299.     {
  300.         $pre = [];
  301.         $post = [];
  303.         foreach ($bundles as $index => $bundle) {
  304.             if (\is_int($index) && $index < 0) {
  305.                 $pre[$index] = $bundle;
  306.             } else {
  307.                 $post[$index] = $bundle;
  308.             }
  309.         }
  311.         \ksort($pre);
  312.         \ksort($post);
  314.         return [$pre, $post];
  315.     }
  316. }