feat: unify all integrations on single Symfony-based container with dumped cache

.github/workflows/split-testing.yml

@@ -175,6 +175,12 @@ jobs:
             local run_tests_cmd="$3"
             local overall_exit_code=0
 
+            # Isolate temp directory per component, so parallel PHPStan runs do not race on a shared /tmp/phpstan cache
+            local tmp_slug=$(echo "$dir" | tr '/.-' '___' | tr '[:upper:]' '[:lower:]')
+            local component_tmp_dir="/tmp/ecotone_component_${tmp_slug}"
+            mkdir -p "$component_tmp_dir"
+            run_tests_cmd="TMPDIR='${component_tmp_dir}' ${run_tests_cmd}"
+
             # Install dependencies and determine if MySQL pass is needed (direct or transitive doctrine/dbal)
             if ! _run_tests "Install composer dependencies ($dir)" "cd '${dir}' && ${compose_up_cmd}"; then
               overall_exit_code=1

composer.json

@@ -160,7 +160,6 @@
         "symfony/console": "^6.4|^7.0|^8.0",
         "symfony/framework-bundle": "^6.4|^7.0|^8.0",
         "symfony/dependency-injection": "^6.4|^7.0|^8.0",
-        "php-di/php-di": "^7.0.5",
         "open-telemetry/sdk": "^1.0.0",
         "psr/container": "^1.1.1|^2.0.1",
         "psr/clock": "^1.0",

packages/Ecotone/composer.json

@@ -57,6 +57,7 @@
         "psr/clock": "^1.0",
         "psr/container": "^1.1.1|^2.0.1",
         "psr/log": "^2.0|^3.0",
+        "symfony/dependency-injection": "^6.4|^7.0|^8.0",
         "symfony/uid": "^6.4|^7.0|^8.0"
     },
     "require-dev": {

packages/Ecotone/src/Lite/EcotoneLite.php

@@ -4,7 +4,6 @@
 
 namespace Ecotone\Lite;
 
-use Ecotone\AnnotationFinder\AnnotationFinderFactory;
 use Ecotone\AnnotationFinder\FileSystem\FileSystemAnnotationFinder;
 use Ecotone\AnnotationFinder\FileSystem\RootCatalogNotFound;
 use Ecotone\Dbal\Configuration\DbalConfiguration;
@@ -15,7 +14,6 @@
 use Ecotone\Lite\Test\TestConfiguration;
 use Ecotone\Messaging\Channel\MessageChannelBuilder;
 use Ecotone\Messaging\Config\ConfiguredMessagingSystem;
-use Ecotone\Messaging\Config\Container\ContainerConfig;
 use Ecotone\Messaging\Config\MessagingSystemConfiguration;
 use Ecotone\Messaging\Config\ModulePackageList;
 use Ecotone\Messaging\Config\ServiceCacheConfiguration;
@@ -24,6 +22,8 @@
 use Ecotone\Messaging\InMemoryConfigurationVariableService;
 use Ecotone\Messaging\Support\Assert;
 use Ecotone\Modelling\BaseEventSourcingConfiguration;
+use Ecotone\SymfonyContainer\ContainerCacheLayout;
+use Ecotone\SymfonyContainer\EcotoneSymfonyContainerFactory;
 
 use function json_decode;
 
@@ -202,63 +202,46 @@ private static function prepareConfiguration(ContainerInterface|array $container
         $externalContainer = $containerOrAvailableServices instanceof ContainerInterface ? $containerOrAvailableServices : InMemoryPSRContainer::createFromAssociativeArray($containerOrAvailableServices);
         $serviceConfiguration = MessagingSystemConfiguration::addCorePackage($serviceConfiguration, $enableTesting);
 
-        $annotationFinder = AnnotationFinderFactory::createForAttributes(
-            realpath($pathToRootCatalog),
-            $serviceConfiguration->getNamespaces(),
-            $serviceConfiguration->getEnvironment(),
-            $serviceConfiguration->getLoadedCatalog() ?? '',
-            MessagingSystemConfiguration::getModuleClassesFor($serviceConfiguration),
-            $classesToResolve,
-            $enableTesting
-        );
-        $cacheHash = $annotationFinder->getCacheMessagingFileNameBasedOnConfig($pathToRootCatalog, $serviceConfiguration, $configurationVariables, $enableTesting);
-        $serviceCacheConfiguration = new ServiceCacheConfiguration(
-            $serviceConfiguration->getCacheDirectoryPath() . DIRECTORY_SEPARATOR . $cacheHash,
+        $cacheLayout = ContainerCacheLayout::resolve(
+            $pathToRootCatalog,
+            $serviceConfiguration,
+            $serviceConfiguration->getCacheDirectoryPath(),
             self::shouldUseAutomaticCache($useCachedVersion, $pathToRootCatalog),
+            configurationVariables: $configurationVariables,
+            classesToResolve: $classesToResolve,
+            enableTesting: $enableTesting,
         );
+        $annotationFinder = $cacheLayout->annotationFinder;
+        $serviceCacheConfiguration = $cacheLayout->serviceCacheConfiguration;
+        $cacheHash = $cacheLayout->configHash;
 
         $configurationVariableService = InMemoryConfigurationVariableService::create($configurationVariables);
-        $definitionHolder = null;
-        $messagingSystemCachePath = $serviceCacheConfiguration->getPath() . DIRECTORY_SEPARATOR . 'messaging';
-
-        if ($serviceCacheConfiguration->shouldUseCache() && file_exists($messagingSystemCachePath)) {
-            /** It may fail on deserialization, then return `false` and we can build new one */
-            $definitionHolder = unserialize(file_get_contents($messagingSystemCachePath));
-        }
-
-        if (! $definitionHolder) {
-            $messagingConfiguration = MessagingSystemConfiguration::prepareWithAnnotationFinder(
-                $annotationFinder,
-                $configurationVariableService,
-                $serviceConfiguration,
-                $enableTesting
-            );
-
-            $messagingConfiguration->withExternalContainer($externalContainer);
 
-            $definitionHolder = ContainerConfig::buildDefinitionHolder($messagingConfiguration);
-
-            if ($serviceCacheConfiguration->shouldUseCache()) {
-                Assert::notNull($messagingSystemCachePath, 'Cache path should be defined');
-
-                MessagingSystemConfiguration::prepareCacheDirectory($serviceCacheConfiguration);
-                file_put_contents($messagingSystemCachePath, serialize($definitionHolder));
-            }
-        }
-
-        $container = new LazyInMemoryContainer($definitionHolder->getDefinitions(), $externalContainer);
-        $container->set(ServiceCacheConfiguration::class, $serviceCacheConfiguration);
-        $container->set(ConfigurationVariableService::REFERENCE_NAME, $configurationVariableService);
+        $container = EcotoneSymfonyContainerFactory::bootstrap(
+            $serviceCacheConfiguration,
+            $configurationVariableService,
+            $externalContainer,
+            function () use ($annotationFinder, $configurationVariableService, $serviceConfiguration, $enableTesting, $externalContainer) {
+                $messagingConfiguration = MessagingSystemConfiguration::prepareWithAnnotationFinder(
+                    $annotationFinder,
+                    $configurationVariableService,
+                    $serviceConfiguration,
+                    $enableTesting
+                );
+                $messagingConfiguration->withExternalContainer($externalContainer);
+
+                return $messagingConfiguration;
+            },
+            $cacheHash,
+        );
 
         $messagingSystem = $container->get(ConfiguredMessagingSystem::class);
 
         if ($allowGatewaysToBeRegisteredInContainer) {
             Assert::isTrue(method_exists($externalContainer, 'set'), 'Gateways registration was enabled however given container has no `set` method. Please add it or turn off the option.');
-            $externalContainer->set(ConfiguredMessagingSystem::class, $messagingSystem);
-            foreach ($messagingSystem->getGatewayList() as $gatewayReference) {
-                $gatewayReferenceName = $gatewayReference->getReferenceName();
-                $externalContainer->set($gatewayReferenceName, $messagingSystem->getGatewayByName($gatewayReferenceName));
-            }
+            $container->registerBridgesInto(
+                fn (string $referenceName, string $interfaceName, callable $factory) => $externalContainer->set($referenceName, $factory()),
+            );
         } elseif ($externalContainer->has(ConfiguredMessagingSystem::class)) {
             /** @var ConfiguredMessagingSystem $alreadyConfiguredMessaging */
             $alreadyConfiguredMessaging = $externalContainer->get(ConfiguredMessagingSystem::class);