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

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework\Plugin\KernelPluginLoader;
  5. use Composer\Autoload\ClassLoader;
  6. use Shopware\Core\Framework\Log\Package;
  7. use Shopware\Core\Framework\Parameter\AdditionalBundleParameters;
  8. use Shopware\Core\Framework\Plugin;
  9. use Shopware\Core\Framework\Plugin\Exception\KernelPluginLoaderException;
  10. use Shopware\Core\Framework\Plugin\KernelPluginCollection;
  11. use Symfony\Component\DependencyInjection\ContainerBuilder;
  12. use Symfony\Component\DependencyInjection\Definition;
  13. use Symfony\Component\DependencyInjection\Reference;
  14. use Symfony\Component\HttpKernel\Bundle\Bundle;
  16. #[Package('core')]
  17. abstract class KernelPluginLoader extends Bundle
  18. {
  19.     /**
  20.      * @var array<int, mixed>
  21.      */
  22.     protected $pluginInfos = [];
  24.     private readonly KernelPluginCollection $pluginInstances;
  26.     private readonly string $pluginDir;
  28.     private bool $initialized = false;
  30.     /**
  31.      * @internal
  32.      */
  33.     public function __construct(
  34.         private readonly ClassLoader $classLoader,
  35.         ?string $pluginDir = null
  36.     ) {
  37.         $this->pluginDir = $pluginDir ?? 'custom/plugins';
  38.         $this->pluginInstances = new KernelPluginCollection();
  39.     }
  41.     final public function getPluginDir(string $projectDir): string
  42.     {
  43.         // absolute path
  44.         if (mb_strpos($this->pluginDir, '/') === 0) {
  45.             return $this->pluginDir;
  46.         }
  48.         return $projectDir . '/' . $this->pluginDir;
  49.     }
  51.     /**
  52.      * @return array<int, mixed>
  53.      * Basic information required for instantiating the plugins
  54.      */
  55.     final public function getPluginInfos(): array
  56.     {
  57.         return $this->pluginInfos;
  58.     }
  60.     /**
  61.      * @final
  62.      * Instances of the plugin bundle classes
  63.      */
  64.     public function getPluginInstances(): KernelPluginCollection
  65.     {
  66.         return $this->pluginInstances;
  67.     }
  69.     /**
  70.      * @param array<string, mixed> $kernelParameters
  71.      * @param array<int, string> $loadedBundles
  72.      *
  73.      * @return \Traversable<Bundle>
  74.      */
  75.     final public function getBundles(array $kernelParameters = [], array $loadedBundles = []): iterable
  76.     {
  77.         if (!$this->initialized) {
  78.             return;
  79.         }
  81.         foreach ($this->pluginInstances->getActives() as $plugin) {
  82.             $copy = new KernelPluginCollection($this->getPluginInstances()->all());
  83.             $additionalBundleParameters = new AdditionalBundleParameters($this->classLoader, $copy, $kernelParameters);
  84.             $additionalBundles = $plugin->getAdditionalBundles($additionalBundleParameters);
  85.             [$preLoaded, $postLoaded] = $this->splitBundlesIntoPreAndPost($additionalBundles);
  87.             foreach ([...\array_values($preLoaded), $plugin, ...\array_values($postLoaded)] as $bundle) {
  88.                 if (!\in_array($bundle->getName(), $loadedBundles, true)) {
  89.                     yield $bundle;
  90.                     $loadedBundles[] = $bundle->getName();
  91.                 }
  92.             }
  93.         }
  95.         if (!\in_array($this->getName(), $loadedBundles, true)) {
  96.             yield $this;
  97.         }
  98.     }
  100.     /**
  101.      * @throws KernelPluginLoaderException
  102.      */
  103.     final public function initializePlugins(string $projectDir): void
  104.     {
  105.         if ($this->initialized) {
  106.             return;
  107.         }
  109.         $this->loadPluginInfos();
  110.         if (empty($this->pluginInfos)) {
  111.             $this->initialized = true;
  113.             return;
  114.         }
  116.         $this->registerPluginNamespaces($projectDir);
  117.         $this->instantiatePlugins($projectDir);
  119.         $this->initialized = true;
  120.     }
  122.     final public function build(ContainerBuilder $container): void
  123.     {
  124.         if (!$this->initialized) {
  125.             return;
  126.         }
  128.         parent::build($container);
  130.         /*
  131.          * Register every plugin in the di container, enable autowire and set public
  132.          */
  133.         foreach ($this->pluginInstances->getActives() as $plugin) {
  134.             $class = $plugin::class;
  136.             $definition = new Definition();
  137.             if ($container->hasDefinition($class)) {
  138.                 $definition = $container->getDefinition($class);
  139.             }
  141.             $definition->setFactory([new Reference(self::class), 'getPluginInstance']);
  142.             $definition->addArgument($class);
  144.             $definition->setAutowired(true);
  145.             $definition->setPublic(true);
  147.             $container->setDefinition($class, $definition);
  148.         }
  149.     }
  151.     final public function getPluginInstance(string $class): ?Plugin
  152.     {
  153.         $plugin = $this->pluginInstances->get($class);
  154.         if (!$plugin || !$plugin->isActive()) {
  155.             return null;
  156.         }
  158.         return $plugin;
  159.     }
  161.     public function getClassLoader(): ClassLoader
  162.     {
  163.         return $this->classLoader;
  164.     }
  166.     abstract protected function loadPluginInfos(): void;
  168.     /**
  169.      * @throws KernelPluginLoaderException
  170.      */
  171.     private function registerPluginNamespaces(string $projectDir): void
  172.     {
  173.         foreach ($this->pluginInfos as $plugin) {
  174.             \assert(\is_string($plugin['baseClass']));
  175.             $pluginName = $plugin['name'] ?? $plugin['baseClass'];
  177.             // plugins managed by composer are already in the classMap
  178.             if ($plugin['managedByComposer']) {
  179.                 continue;
  180.             }
  182.             if (!isset($plugin['autoload'])) {
  183.                 $reason = sprintf(
  184.                     'Unable to register plugin "%s" in autoload. Required property `autoload` missing.',
  185.                     $plugin['baseClass']
  186.                 );
  188.                 throw new KernelPluginLoaderException($pluginName, $reason);
  189.             }
  191.             $psr4 = $plugin['autoload']['psr-4'] ?? [];
  192.             $psr0 = $plugin['autoload']['psr-0'] ?? [];
  194.             if (empty($psr4) && empty($psr0)) {
  195.                 $reason = sprintf(
  196.                     'Unable to register plugin "%s" in autoload. Required property `psr-4` or `psr-0` missing in property autoload.',
  197.                     $plugin['baseClass']
  198.                 );
  200.                 throw new KernelPluginLoaderException($pluginName, $reason);
  201.             }
  203.             foreach ($psr4 as $namespace => $paths) {
  204.                 if (\is_string($paths)) {
  205.                     $paths = [$paths];
  206.                 }
  207.                 $mappedPaths = $this->mapPsrPaths($pluginName, $paths, $projectDir, $plugin['path']);
  208.                 $this->classLoader->addPsr4($namespace, $mappedPaths);
  209.                 if ($this->classLoader->isClassMapAuthoritative()) {
  210.                     $this->classLoader->setClassMapAuthoritative(false);
  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.                     $this->classLoader->setClassMapAuthoritative(false);
  223.                 }
  224.             }
  225.         }
  226.     }
  228.     /**
  229.      * @param array<string> $psr
  230.      *
  231.      * @throws KernelPluginLoaderException
  232.      *
  233.      * @return array<string>
  234.      */
  235.     private function mapPsrPaths(string $plugin, array $psr, string $projectDir, string $pluginRootPath): array
  236.     {
  237.         $mappedPaths = [];
  239.         $absolutePluginRootPath = $this->getAbsolutePluginRootPath($projectDir, $pluginRootPath);
  241.         if (mb_strpos($absolutePluginRootPath, $projectDir) !== 0) {
  242.             throw new KernelPluginLoaderException(
  243.                 $plugin,
  244.                 sprintf('Plugin dir %s needs to be a sub-directory of the project dir %s', $pluginRootPath, $projectDir)
  245.             );
  246.         }
  248.         foreach ($psr as $path) {
  249.             $mappedPaths[] = $absolutePluginRootPath . '/' . $path;
  250.         }
  252.         return $mappedPaths;
  253.     }
  255.     private function getAbsolutePluginRootPath(string $projectDir, string $pluginRootPath): string
  256.     {
  257.         // is relative path
  258.         if (mb_strpos($pluginRootPath, '/') !== 0) {
  259.             $pluginRootPath = $projectDir . '/' . $pluginRootPath;
  260.         }
  262.         return $pluginRootPath;
  263.     }
  265.     /**
  266.      * @throws KernelPluginLoaderException
  267.      */
  268.     private function instantiatePlugins(string $projectDir): void
  269.     {
  270.         foreach ($this->pluginInfos as $pluginData) {
  271.             $className = $pluginData['baseClass'];
  273.             $pluginClassFilePath = $this->classLoader->findFile($className);
  274.             if (!class_exists($className) || !$pluginClassFilePath || !file_exists($pluginClassFilePath)) {
  275.                 continue;
  276.             }
  278.             /** @var Plugin $plugin */
  279.             $plugin = new $className((bool) $pluginData['active'], $pluginData['path'], $projectDir);
  281.             if (!$plugin instanceof Plugin) {
  282.                 $reason = sprintf('Plugin class "%s" must extend "%s"', $plugin::class, Plugin::class);
  284.                 throw new KernelPluginLoaderException($pluginData['name'], $reason);
  285.             }
  287.             $this->pluginInstances->add($plugin);
  288.         }
  289.     }
  291.     /**
  292.      * @param Bundle[] $bundles
  293.      *
  294.      * @return array<Bundle[]>
  295.      */
  296.     private function splitBundlesIntoPreAndPost(array $bundles): array
  297.     {
  298.         $pre = [];
  299.         $post = [];
  301.         foreach ($bundles as $index => $bundle) {
  302.             if (\is_int($index) && $index < 0) {
  303.                 $pre[$index] = $bundle;
  304.             } else {
  305.                 $post[$index] = $bundle;
  306.             }
  307.         }
  309.         \ksort($pre);
  310.         \ksort($post);
  312.         return [$pre, $post];
  313.     }
  314. }