Create a service adapter for drush.services.yml

src/Boot/DrupalBoot8.php

@@ -12,14 +12,15 @@
 use Drupal\Core\Session\AnonymousUserSession;
 use Drush\Config\ConfigLocator;
 use Drush\Drupal\DrushLoggerServiceProvider;
-use Drush\Drupal\DrushServiceModifier;
 use Drush\Drush;
 use Psr\Log\LoggerInterface;
 use Symfony\Component\Filesystem\Path;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Consolidation\AnnotatedCommand\CommandFileDiscovery;
 use Robo\Robo;
+use Drush\Runtime\LegacyServiceInstantiator;
+use Drush\Runtime\LegacyServiceFinder;
 
 class DrupalBoot8 extends DrupalBoot implements AutoloaderAwareInterface
 {
@@ -29,6 +30,10 @@ class DrupalBoot8 extends DrupalBoot implements AutoloaderAwareInterface
     protected ?DrupalKernelInterface $kernel = null;
     protected Request $request;
 
+    public function __construct(protected $serviceManager)
+    {
+    }
+
     public function getRequest(): Request
     {
         return $this->request;
@@ -217,9 +222,6 @@ public function bootstrapDrupalConfiguration(BootstrapManager $manager, Annotati
         $allow_dumping = $kernel !== Kernels::UPDATE;
         /** @var DrupalKernelInterface kernel */
         $this->kernel = $kernel_factory($request, $classloader, 'prod', $allow_dumping, $manager->getRoot());
-        // Include Drush services in the container.
-        // @see Drush\Drupal\DrupalKernel::addServiceModifier()
-        $this->kernel->addServiceModifier(new DrushServiceModifier());
 
         // Unset drupal error handler and restore Drush's one.
         restore_error_handler();
@@ -247,13 +249,22 @@ public function bootstrapDrupalFull(BootstrapManager $manager): void
     public function addDrupalModuleDrushCommands($manager): void
     {
         $application = Drush::getApplication();
+        $drushContainer = Drush::getContainer();
+
+        $this->logger->debug(dt("Loading drupal module drush commands & etc.", []));
 
         // We have to get the service command list from the container, because
         // it is constructed in an indirect way during the container initialization.
         // The upshot is that the list of console commands is not available
         // until after $kernel->boot() is called.
         $container = \Drupal::getContainer();
 
+        // Legacy service adapters for drush.services.yml files.
+        $serviceFinder = new LegacyServiceFinder(\Drupal::moduleHandler(), Drush::config());
+        $drushServiceFiles = $serviceFinder->getDrushServiceFiles();
+        $legacyServiceInstantiator = new LegacyServiceInstantiator($container);
+        $legacyServiceInstantiator->loadServiceFiles($drushServiceFiles);
+
         // Find the containerless commands, generators and command info alterers
         $bootstrapCommandClasses = $application->bootstrapCommandClasses();
         $commandInfoAlterers = [];
@@ -265,37 +276,37 @@ public function addDrupalModuleDrushCommands($manager): void
             $commandInfoAlterers = array_merge($commandInfoAlterers, $commandInfoAlterersInThisModule);
         }
 
+        // Look up the generators from the legacy service instantiator and inject
+        // them into the service manager. The `generate` command will get the
+        // generators from the service manager.
+        $this->serviceManager->injectGenerators($legacyServiceInstantiator->taggedServices('drush.generator.v3'));
+
         // Find the command info alterers in Drush services.
-        if ($container->has(DrushServiceModifier::DRUSH_COMMAND_INFO_ALTERER_SERVICES)) {
-            $serviceCommandInfoAltererList = $container->get(DrushServiceModifier::DRUSH_COMMAND_INFO_ALTERER_SERVICES);
-            $commandFactory = Drush::commandFactory();
-            $commandInfoAlterers = array_merge($commandInfoAlterers, $serviceCommandInfoAltererList->getCommandList());
-        }
+        $commandFactory = Drush::commandFactory();
+        $commandInfoAlterers = array_merge($commandInfoAlterers, $legacyServiceInstantiator->taggedServices('drush.command_info_alterer'));
 
-        // Set the command info alterers.
-        foreach ($serviceCommandInfoAltererList->getCommandList() as $altererHandler) {
+        // Set the command info alterers. We must do this prior to calling
+        // Robo::register to add any commands, as that is the point where the
+        // alteration will happen.
+        foreach ($commandInfoAlterers as $altererHandler) {
             $commandFactory->addCommandInfoAlterer($altererHandler);
             $this->logger->debug(dt('Commands are potentially altered in !class.', ['!class' => get_class($altererHandler)]));
         }
 
         // Register the Drush Symfony Console commands found in Drush services
-        if ($container->has(DrushServiceModifier::DRUSH_CONSOLE_SERVICES)) {
-            $serviceCommandList = $container->get(DrushServiceModifier::DRUSH_CONSOLE_SERVICES);
-            foreach ($serviceCommandList->getCommandList() as $command) {
-                $manager->inflect($command);
-                $this->logger->debug(dt('Add a command: !name', ['!name' => $command->getName()]));
-                $application->add($command);
-            }
+        $drushServicesConsoleCommands = $legacyServiceInstantiator->taggedServices('console.command');
+        foreach ($drushServicesConsoleCommands as $command) {
+            $manager->inflect($command);
+            $this->logger->debug(dt('Add a command: !name', ['!name' => $command->getName()]));
+            $application->add($command);
         }
 
-        // Do the same thing with the annotation commands.
-        if ($container->has(DrushServiceModifier::DRUSH_COMMAND_SERVICES)) {
-            $serviceCommandList = $container->get(DrushServiceModifier::DRUSH_COMMAND_SERVICES);
-            foreach ($serviceCommandList->getCommandList() as $commandHandler) {
-                $manager->inflect($commandHandler);
-                $this->logger->debug(dt('Add a commandfile class: !name', ['!name' => get_class($commandHandler)]));
-                Robo::register($application, $commandHandler);
-            }
+        // Add annotation commands from drush.services.yml
+        $drushServicesCommandHandlers = $legacyServiceInstantiator->taggedServices('drush.command');
+        foreach ($drushServicesCommandHandlers as $commandHandler) {
+            $manager->inflect($commandHandler);
+            $this->logger->debug(dt('Add a commandfile class: !name', ['!name' => get_class($commandHandler)]));
+            Robo::register($application, $commandHandler);
         }
 
         // Finally, instantiate all of the classes we discovered in
@@ -309,13 +320,15 @@ public function addDrupalModuleDrushCommands($manager): void
                 // of double-instantiating Drush service commands, if anyone decided
                 // to put those in the same namespace (\Drupal\modulename\Drush\Commands)
                 if ($this->hasStaticCreateFactory($class)) {
-                    $commandHandler = $class::create($container);
+                    $commandHandler = $class::create($container, $drushContainer);
                 }
             } catch (\Exception $e) {
             }
             // Fail silently if the command handler could not be
             // instantiated, e.g. if it tries to fetch services from
-            // a module that has not been enabled.
+            // a module that has not been enabled. Note that Robo::register
+            // can accept either Annotated Command command handlers or
+            // Symfony Console Command objects.
             if ($commandHandler) {
                 $manager->inflect($commandHandler);
                 Robo::register($application, $commandHandler);

src/Drupal/Commands/generate/ApplicationFactory.php

@@ -48,10 +48,8 @@ public function discover(): array
         $global_generators = $this->discoverPsr4Generators();
 
         $module_generators = [];
-        if ($this->container->has(DrushServiceModifier::DRUSH_GENERATOR_SERVICES)) {
-            $module_generators = $this->container->get(DrushServiceModifier::DRUSH_GENERATOR_SERVICES)->getCommandList(
-            );
-        }
+        $serviceManager = \Drush\Drush::service('service.manager');
+        $module_generators = $serviceManager->getGenerators();
 
         $generators = [
             new DrushCommandFile(),

src/Drupal/DrupalKernelTrait.php

@@ -17,6 +17,13 @@ trait DrupalKernelTrait
 {
     /** @var ServiceModifierInterface[] */
     protected $serviceModifiers = [];
+    protected $serviceFinder;
+    protected $drushServiceYamls = [];
+
+    public function getDrushServiceFiles()
+    {
+        return $this->drushServiceYamls;
+    }
 
     /**
      * Add a service modifier to the container builder.
@@ -92,6 +99,11 @@ public function discoverServiceProviders()
         // Let Drupal discover all of its service providers
         parent::discoverServiceProviders();
 
+        $this->discoverDrushServiceProviders();
+    }
+
+    protected function discoverDrushServiceProviders()
+    {
         // Add those Drush service providers from Drush core that
         // need references to the Drupal DI container. This includes
         // Drush commands, and those services needed by those Drush
@@ -209,7 +221,11 @@ protected function findAppropriateServicesFile($module, $services, $dir)
     protected function addDrushServiceProvider($serviceProviderName, $serviceYmlPath = '')
     {
         if (($serviceYmlPath !== null) && file_exists($serviceYmlPath)) {
-            $this->serviceYamls['app'][$serviceProviderName] = $serviceYmlPath;
+            // Keep our own list of service files
+            $this->drushServiceYamls[$serviceProviderName] = $serviceYmlPath;
+            // This is how we used to add our drush.services.yml file
+            // to the Drush service container. This is no longer necessary.
+            //$this->serviceYamls['app'][$serviceProviderName] = $serviceYmlPath;
         }
     }
 }

src/Runtime/DependencyInjection.php

@@ -117,7 +117,10 @@ protected function addDrushServices($container, ClassLoader $loader, DrushDrupal
             ->addMethodCall('addDefaultSimplifiers', []);
 
         // Add some of our own objects to the container
-        Robo::addShared($container, 'bootstrap.drupal8', 'Drush\Boot\DrupalBoot8');
+        Robo::addShared($container, 'service.manager', 'Drush\Runtime\ServiceManager')
+            ->addArgument('loader');
+        Robo::addShared($container, 'bootstrap.drupal8', 'Drush\Boot\DrupalBoot8')
+            ->addArgument('service.manager');
         Robo::addShared($container, 'bootstrap.manager', 'Drush\Boot\BootstrapManager')
             ->addMethodCall('setDrupalFinder', [$drupalFinder]);
         // TODO: Can we somehow add these via discovery (e.g. backdrop extension?)

src/Runtime/LegacyServiceFinder.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drush\Runtime;
+
+use Drush\Log\Logger;
+use League\Container\Container;
+use Drush\Drush;
+use Symfony\Component\Console\Application;
+use Composer\Autoload\ClassLoader;
+use Drush\Command\DrushCommandInfoAlterer;
+use Psr\Container\ContainerInterface;
+use League\Container\Container as DrushContainer;
+use Drush\Drupal\DrupalKernelTrait;
+use Drush\Config\DrushConfig;
+
+/**
+ * Find drush.services.yml files.
+ *
+ * This discovery class is used solely for backwards compatability with
+ * Drupal modules that still use drush.services.ymls to define Drush
+ * Commands, Generators & etc.; this mechanism is deprecated, though.
+ * Modules should instead use the static factory `create` mechanism.
+ */
+class LegacyServiceFinder
+{
+    // We get the discovery code we need from the DrupalKernelTrait.
+    // We could also just move the code from there to here eventually,
+    // as that trait won't be needed once this class is used exclusively.
+    use DrupalKernelTrait;
+
+    protected $drushServiceYamls = [];
+
+    public function __construct(protected $moduleHandler, protected DrushConfig $drushConfig)
+    {
+    }
+
+    public function getDrushServiceFiles()
+    {
+        if (empty($drushServiceYamls)) {
+            $this->discoverDrushServiceProviders();
+        }
+        return $this->drushServiceYamls;
+    }
+
+    protected function getModuleFileNames()
+    {
+        $modules = $this->moduleHandler->getModuleList();
+        $moduleFilenames = [];
+
+        foreach ($modules as $module => $extension) {
+            $moduleFilenames[$module] = $extension->getPathname();
+        }
+
+        return $moduleFilenames;
+    }
+}