/** * @param string $id * @return string */ public function definitionClass(string $id) : string { if ($this->builder->hasAlias($id)) { return $this->builder->getDefinition((string) $this->builder->getAlias($id))->getClass()->getClass(); } return $this->builder->getDefinition($id)->getClass(); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if ($container->hasParameter('default_backend')) { $default_backend = $container->getParameter('default_backend'); // Opt out from the default backend. if (!$default_backend) { return; } } else { try { $default_backend = $container->get('database')->driver(); $container->set('database', NULL); } catch (\Exception $e) { // If Drupal is not installed or a test doesn't define database there // is nothing to override. return; } } foreach ($container->findTaggedServiceIds('backend_overridable') as $id => $attributes) { // If the service is already an alias it is not the original backend, so // we don't want to fallback to other storages any longer. if ($container->hasAlias($id)) { continue; } if ($container->hasDefinition("{$default_backend}.{$id}") || $container->hasAlias("{$default_backend}.{$id}")) { $container->setAlias($id, new Alias("{$default_backend}.{$id}")); } } }
public function process(ContainerBuilder $container) { // Cache warmer does more harm than good with Drupal. if ($container->hasDefinition('cache_warmer')) { $container->removeDefinition('cache_warmer'); } if ($container->hasAlias('cache_warmer')) { $container->removeAlias('cache_warmer'); } // When not working with symfony, we need to provide a file locator // service of our own instead of the symfony's one if (!$container->hasDefinition('file_locator') && !$container->hasAlias('file_locator')) { $container->addDefinitions(['file_locator' => (new Definition())->setClass(CustomFileLocator::class)->addArgument(new Reference('kernel'))]); } else { // We are working with fullstack, and our users might have changed // the global resource directory to somewhere safer than Drupal's // sites/SITE folder, case in which we must honnor the user's // configuration $definition = $container->getDefinition('file_locator'); $definition->setArguments([new Reference('kernel'), $container->getParameter('kernel.root_dir') . '/Resources']); } // By registering the framework bundle, we also inherit from Symfony // default URL generator, which will cause us great pain because of // Drupal routes will not be known by the framework and throw a few // exceptions. if ($container->has('router.default')) { $container->getDefinition('router.default')->setClass('MakinaCorpus\\Drupal\\Sf\\Routing\\Router'); } // When NOT in fullstack mode, we need to provide a null implementation // for the controller resolver service, else the container will be // unable to spawn the http kernel service if (!$container->has('controller_resolver')) { $container->addDefinitions(['controller_resolver' => (new Definition())->setClass('controller_resolver')]); } }
public function process( ContainerBuilder $container ) { if ( !$container->hasAlias( 'session.storage' ) ) { return; } $sessionStorageAlias = $container->getAlias( 'session.storage' ); $sessionStorageProxyDef = $container->findDefinition( 'ezpublish_legacy.session_storage_proxy' ); $sessionStorageProxyDef->replaceArgument( 1, new Reference( (string)$sessionStorageAlias ) ); $container->setAlias( 'session.storage', 'ezpublish_legacy.session_storage_proxy' ); if ( $container->hasAlias( 'session.handler' ) ) { $sessionHandlerAlias = $container->getAlias( 'session.handler' ); $interfaces = class_implements( $container->findDefinition( (string)$sessionHandlerAlias ) ); // Only swap session handler if it implements appropriate interface. if ( isset( $interfaces['SessionHandlerInterface'] ) ) { $sessionHandlerProxyDef = $container->findDefinition( 'ezpublish_legacy.session_handler_proxy' ); $sessionHandlerProxyDef->replaceArgument( 1, new Reference( (string)$sessionHandlerAlias ) ); $container->setAlias( 'session.handler', 'ezpublish_legacy.session_handler_proxy' ); } } }
public function testNoDefaultPheanstalk() { $config = ['leezy_pheanstalk' => ['pheanstalks' => ['primary' => ['server' => 'beanstalkd.domain.tld', 'port' => 11300, 'timeout' => 60]]]]; $this->extension->load($config, $this->container); $this->container->compile(); $this->assertTrue($this->container->hasDefinition('leezy.pheanstalk.primary')); $this->assertFalse($this->container->hasAlias('leezy.pheanstalk')); }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { $handlers = $container->getParameter('monolog.swift_mailer.handlers'); foreach ($handlers as $id) { $definition = $container->getDefinition($id); if ($container->hasAlias('swiftmailer.transport.real') || $container->hasDefinition('swiftmailer.transport.real')) { $definition->addMethodCall('setTransport', array(new Reference('swiftmailer.transport.real'))); } elseif ($container->hasAlias('swiftmailer.transport') || $container->hasDefinition('swiftmailer.transport')) { $definition->addMethodCall('setTransport', array(new Reference('swiftmailer.transport'))); } } }
public function testCreateClients() { $config = array('zeichen32_git_lab_api' => array('clients' => array('firstclient' => array('token' => '12345', 'url' => 'http://example.org/api/v3/'), 'secondclient' => array('token' => '12345', 'url' => 'http://example.com/api/v3/')))); $this->extension->load($config, $this->container); $this->assertTrue($this->container->hasAlias('zeichen32_gitlabapi.client.default')); $this->assertTrue($this->container->has('gitlab_api')); $this->assertTrue($this->container->has('zeichen32_gitlabapi.client.firstclient')); $this->assertTrue($this->container->has('zeichen32_gitlabapi.client.secondclient')); $this->assertInstanceOf('Gitlab\\Client', $this->container->get('zeichen32_gitlabapi.client.default')); $this->assertInstanceOf('Gitlab\\Client', $this->container->get('zeichen32_gitlabapi.client.firstclient')); $this->assertInstanceOf('Gitlab\\Client', $this->container->get('zeichen32_gitlabapi.client.secondclient')); $this->assertNotSame($this->container->get('zeichen32_gitlabapi.client.firstclient'), $this->container->get('zeichen32_gitlabapi.client.secondclient')); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!($container->hasDefinition($this->queueEngineService) || !$container->hasAlias($this->queueEngineService)) && !($container->hasDefinition($this->dispatcherService) || $container->hasAlias($this->dispatcherService))) { return; } $dispatcher = $container->getDefinition($this->dispatcherService); foreach ($container->findTaggedServiceIds($this->jobTag) as $id => $tags) { foreach ($tags as $tag) { // workaround $dispatcher->addMethodCall('addListenerService', array($tag['type'], array($this->queueEngineService, 'process'))); } } }
public function process(ContainerBuilder $container) { if (!$container->hasAlias('logger') || !$container->hasAlias('translator')) { return; } if ($container->hasParameter('translator.logging') && $container->getParameter('translator.logging')) { $translatorAlias = $container->getAlias('translator'); $definition = $container->getDefinition((string) $translatorAlias); $class = $container->getParameterBag()->resolveValue($definition->getClass()); if (is_subclass_of($class, 'Symfony\\Component\\Translation\\TranslatorInterface') && is_subclass_of($class, 'Symfony\\Component\\Translation\\TranslatorBagInterface')) { $container->getDefinition('translator.logging')->setDecoratedService('translator'); $container->getDefinition('translation.warmer')->replaceArgument(0, new Reference('translator.logging.inner')); } } }
public function process(ContainerBuilder $container) { if (!$container->hasAlias('logger') || !$container->hasAlias('translator')) { return; } if ($container->getParameter('translator.logging')) { $translatorAlias = $container->getAlias('translator'); $definition = $container->getDefinition((string) $translatorAlias); $class = $container->getParameterBag()->resolveValue($definition->getClass()); $refClass = new \ReflectionClass($class); if ($refClass->implementsInterface('Symfony\\Component\\Translation\\TranslatorInterface') && $refClass->implementsInterface('Symfony\\Component\\Translation\\TranslatorBagInterface')) { $container->getDefinition('translator.logging')->setDecoratedService('translator'); } } }
/** * @param ContainerBuilder $container * @param $serviceName * @param $className * @return $this */ protected function setDefinition(ContainerBuilder $container, $serviceName, $className) { if (!$container->hasDefinition($serviceName) && !$container->hasAlias($serviceName)) { $container->setDefinition($serviceName, new Definition($className)); } return $this; }
public function process(ContainerBuilder $container) { $clearSpoolsId = 'long_running.swift_mailer.clear_spools'; if (!$container->has($clearSpoolsId)) { return; } if (!$container->hasAlias('swiftmailer.mailer') || $container->getParameter('swiftmailer.mailers') === []) { return; } $spoolServiceReferences = []; $realTransportServiceReferences = []; $mailers = $container->getParameter('swiftmailer.mailers'); foreach ($mailers as $name => $mailer) { if ($container->getParameter(sprintf('swiftmailer.mailer.%s.spool.enabled', $name))) { $transport = sprintf('swiftmailer.mailer.%s.transport', $name); $transportDefinition = $container->findDefinition($transport); if (is_a($transportDefinition->getClass(), 'Swift_Transport_SpoolTransport', true)) { $spool = sprintf('swiftmailer.mailer.%s.spool', $name); $spoolDefinition = $container->findDefinition($spool); if (is_a($spoolDefinition->getClass(), 'Swift_MemorySpool', true)) { $realTransport = sprintf('swiftmailer.mailer.%s.transport.real', $name); $spoolServiceReferences[$name] = new Reference($spool); $realTransportServiceReferences[$name] = new Reference($realTransport); } } } } $definition = $container->getDefinition($clearSpoolsId); $definition->replaceArgument(0, $spoolServiceReferences); $definition->replaceArgument(1, $realTransportServiceReferences); }
public function process(ContainerBuilder $container) { // "query.max_query_count" is an array, it is only accessible // through "query" node and getting the "max_query_count" array // key with PHP. $query = $container->getParameter('liip_functional_test.query'); if (null === $query['max_query_count']) { $container->removeDefinition('liip_functional_test.query.count_client'); return; } if ($container->hasDefinition('test.client')) { // test.client is a definition. // Register it again as a private service to inject it as the parent $definition = $container->getDefinition('test.client'); $definition->setPublic(false); $container->setDefinition('liip_functional_test.query.count_client.parent', $definition); } elseif ($container->hasAlias('test.client')) { // test.client is an alias. // Register a private alias for this service to inject it as the parent $container->setAlias('liip_functional_test.query.count_client.parent', new Alias((string) $container->getAlias('test.client'), false)); } else { throw new \Exception('The LiipFunctionalTestBundle\'s Query Counter can only be used in the test environment.' . PHP_EOL . 'See https://github.com/liip/LiipFunctionalTestBundle#only-in-test-environment'); } $container->setAlias('test.client', 'liip_functional_test.query.count_client'); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $tags = $container->findTaggedServiceIds($this->tagName); foreach ($tags as $id => $tag) { /** @var Definition $serviceLinkDef */ $serviceLinkDef = $container->getDefinition($id); if (!isset($tag[0]['service'])) { throw new InvalidArgumentException(sprintf('Tag "%s" for service "%s" does not have required param "service"', $this->tagName, $id)); } $serviceId = $tag[0]['service']; $isOptional = false; if (strpos($serviceId, '?') === 0) { $serviceId = substr($serviceId, 1); $isOptional = true; } if ($container->hasDefinition($serviceId)) { // the service we are referring to must be public $serviceDef = $container->getDefinition($serviceId); if (!$serviceDef->isPublic()) { $serviceDef->setPublic(true); } } elseif ($container->hasAlias($serviceId)) { // the service alias we are referring to must be public $serviceAlias = $container->getAlias($serviceId); if (!$serviceAlias->isPublic()) { $serviceAlias->setPublic(true); } } elseif (!$isOptional) { throw new InvalidArgumentException(sprintf('Target service "%s" is undefined. The service link "%s" with tag "%s" and tag-service "%s"', $serviceId, $id, $this->tagName, $serviceId)); } $serviceLinkDef->setClass($this->decoratorClass)->setPublic(false)->setArguments([new Reference('service_container'), $serviceId, $isOptional]); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $tags = $container->findTaggedServiceIds(self::TAG_NAME); foreach ($tags as $id => $tag) { /** @var Definition $serviceLinkDef */ $serviceLinkDef = $container->getDefinition($id); if (!isset($tag[0]['service'])) { throw new RuntimeException(sprintf('Tag "%s" for service "%s" does not have required param "service"', self::TAG_NAME, $id)); } $serviceId = $tag[0]['service']; $isOptional = false; if (strpos($serviceId, '?') === 0) { $serviceId = substr($serviceId, 1); $isOptional = true; } if ($container->hasDefinition($serviceId)) { // the service we are referring to must be public $serviceDef = $container->getDefinition($serviceId); if (!$serviceDef->isPublic()) { $serviceDef->setPublic(true); } } elseif ($container->hasAlias($serviceId)) { // the service alias we are referring to must be public $serviceAlias = $container->getAlias($serviceId); if (!$serviceAlias->isPublic()) { $serviceAlias->setPublic(true); } } elseif (!$isOptional) { throw new RuntimeException(sprintf('Target service "%s" is undefined. The service link "%s" with tag "%s" and tag-service "%s"', $serviceId, $id, self::TAG_NAME, $serviceId)); } $serviceLinkDef->setClass('Oro\\Bundle\\EntityConfigBundle\\DependencyInjection\\Utils\\ServiceLink')->setPublic(false)->setArguments([new Reference('service_container'), $serviceId, $isOptional]); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition($this->registryService) && !$container->hasAlias($this->registryService)) { return; } $customLogLevels = $container->getParameter('abc.job.logging.level'); $registry = $container->findDefinition('abc.job.registry'); foreach ($container->findTaggedServiceIds($this->jobTag) as $id => $tags) { $def = $container->getDefinition($id); if (!$def->isPublic()) { throw new \InvalidArgumentException(sprintf('The service "%s" must be public as jobs are lazy-loaded.', $id)); } foreach ($tags as $tag) { if (!isset($tag['type'])) { throw new \InvalidArgumentException(sprintf('Service "%s" must define the "type" attribute on "%s" tags.', $id, $this->jobTag)); } if (!isset($tag['method'])) { throw new \InvalidArgumentException(sprintf('Service "%s" must define the "method" attribute on "%s" tags.', $id, $this->jobTag)); } $logLevel = isset($customLogLevels[$tag['type']]) ? $this->levelToMonologConst($customLogLevels[$tag['type']]) : null; $jobTypeId = 'abc.job.type.' . $tag['type']; $definition = $this->createType($id, $tag['type'], array(new Reference($id), $tag['method']), $logLevel); $container->setDefinition($jobTypeId, $definition); $registry->addMethodCall('register', array(new Reference($jobTypeId), true)); } } // there as a reason this listener was registered here, what was it? if ($container->hasParameter('abc.job.adapter') && $container->getParameter('abc.job.adapter') == 'sonata') { $pass = new RegisterSonataListenersPass(); $pass->process($container); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $configuration = $container->getParameter('knp_rad_auto_registration.configuration'); $enable = $configuration['enable']; $generator = $container->get('knp_rad_auto_registration.service_name_generator.bundle_service_name_generator'); foreach ($container->findTaggedServiceIds('knp_rad_auto_registration.definition_builder') as $id => $tags) { $builder = $container->get($id); if (false === $builder->isActive()) { continue; } if (false === in_array($builder->getName(), $this->sections)) { continue; } if (false === array_key_exists($builder->getName(), $enable)) { continue; } $definitions = $builder->buildDefinitions($enable[$builder->getName()]); foreach ($definitions as $class => $definition) { $serviceId = $generator->generateFromClassname($class); if (true === $container->hasDefinition($serviceId)) { continue; } if (true === $container->hasAlias($serviceId)) { continue; } $container->setDefinition($serviceId, $definition); } } }
public function process(ContainerBuilder $container) { $definitions = new \SplPriorityQueue(); $order = PHP_INT_MAX; foreach ($container->getDefinitions() as $id => $definition) { if (!($decorated = $definition->getDecoratedService())) { continue; } $definitions->insert(array($id, $definition), array($decorated[2], --$order)); } foreach ($definitions as list($id, $definition)) { list($inner, $renamedId) = $definition->getDecoratedService(); $definition->setDecoratedService(null); if (!$renamedId) { $renamedId = $id . '.inner'; } // we create a new alias/service for the service we are replacing // to be able to reference it in the new one if ($container->hasAlias($inner)) { $alias = $container->getAlias($inner); $public = $alias->isPublic(); $container->setAlias($renamedId, new Alias((string) $alias, false)); } else { $definition = $container->getDefinition($inner); $public = $definition->isPublic(); $definition->setPublic(false); $container->setDefinition($renamedId, $definition); } $container->setAlias($inner, new Alias($id, $public)); } }
/** * Populate the listener service ids * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { // use main symfony dispatcher if (!$container->hasDefinition('event_dispatcher') && !$container->hasAlias('event_dispatcher')) { return; } $definition = $container->findDefinition('event_dispatcher'); foreach ($container->findTaggedServiceIds('knp_paginator.subscriber') as $id => $attributes) { // We must assume that the class value has been correctly filled, even if the service is created by a factory $class = $container->getDefinition($id)->getClass(); $refClass = new \ReflectionClass($class); $interface = 'Symfony\\Component\\EventDispatcher\\EventSubscriberInterface'; if (!$refClass->implementsInterface($interface)) { throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface)); } foreach ($class::getSubscribedEvents() as $event => $options) { if (!is_array($options)) { $options = array($options, 0); } $definition->addMethodCall('addListenerService', array($event, array($id, $options[0]), $options[1])); } // sf 2.1.x only //$definition->addMethodCall('addSubscriberService', array($id, $class)); } }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { if (!$this->integrationExtension->isTransactionalAutoGenerateProxy()) { // Transactional system or auto generate proxy is disabled return; } $transactionalId = $this->integrationExtension->getTransactionalService(); // Validate transactional service $transactionalDefinition = $container->getDefinition($transactionalId); $class = $transactionalDefinition->getClass(); try { $class = $container->getParameterBag()->resolveValue($class); $refClass = new \ReflectionClass($class); $requiredInterface = 'FivePercent\\Component\\Transactional\\TransactionalInterface'; if (!$refClass->implementsInterface($requiredInterface)) { throw new \RuntimeException(sprintf('The transactional service with class "%s" should implement %s.', $class, $requiredInterface)); } } catch (\Exception $e) { throw new \RuntimeException(sprintf('The transactional service with id "%s" is invalid.', $transactionalId), 0, $e); } // Get all services $serviceIds = $container->getServiceIds(); $directory = $container->getParameter('kernel.cache_dir') . '/transactional'; foreach ($serviceIds as $serviceId) { if ($container->hasAlias($serviceId)) { // Not check in alias. continue; } $serviceDefinition = $container->getDefinition($serviceId); if ($serviceDefinition->isAbstract()) { // Not check in abstract service. continue; } $class = $serviceDefinition->getClass(); $class = $container->getParameterBag()->resolveValue($class); if (!$class) { continue; } try { $proxyCodeGenerator = new ProxyFileGenerator($directory, $class); } catch (\ReflectionException $e) { $container->getCompiler()->addLogMessage(sprintf('%s Error with create proxy code generator for class "%s". Maybe class not found?', get_class($this), $class)); continue; } if ($proxyCodeGenerator->needGenerate()) { // Generate proxy file $filePath = $proxyCodeGenerator->generate(); $serviceDefinition->setClass($proxyCodeGenerator->getProxyClassName()); // Add "__setTransactional" method call for set transactional layer $methodCalls = $serviceDefinition->getMethodCalls(); array_unshift($methodCalls, ['___setTransactional', [new Reference($transactionalId)]]); $serviceDefinition->setMethodCalls($methodCalls); // Add resource for control cache $container->addResource(new FileResource($filePath)); $realClassReflection = new \ReflectionClass($class); $container->addResource(new FileResource($realClassReflection->getFileName())); } } }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition($this->dispatcherService) && !$container->hasAlias($this->dispatcherService)) { return; } $definition = $container->findDefinition($this->dispatcherService); foreach ($container->findTaggedServiceIds($this->listenerTag) as $id => $events) { $def = $container->getDefinition($id); if (!$def->isPublic()) { throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event listeners are lazy-loaded.', $id)); } if ($def->isAbstract()) { throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event listeners are lazy-loaded.', $id)); } foreach ($events as $event) { $priority = isset($event['priority']) ? $event['priority'] : 0; if (!isset($event['event'])) { throw new \InvalidArgumentException(sprintf('Service "%s" must define the "event" attribute on "%s" tags.', $id, $this->listenerTag)); } if (!isset($event['method'])) { $event['method'] = 'on'.preg_replace_callback(array( '/(?<=\b)[a-z]/i', '/[^a-z0-9]/i', ), function ($matches) { return strtoupper($matches[0]); }, $event['event']); $event['method'] = preg_replace('/[^a-z0-9]/i', '', $event['method']); } $definition->addMethodCall('addListenerService', array($event['event'], array($id, $event['method']), $priority)); } } foreach ($container->findTaggedServiceIds($this->subscriberTag) as $id => $attributes) { $def = $container->getDefinition($id); if (!$def->isPublic()) { throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event subscribers are lazy-loaded.', $id)); } if ($def->isAbstract()) { throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event subscribers are lazy-loaded.', $id)); } $class = $container->getParameterBag()->resolveValue($def->getClass()); $refClass = new \ReflectionClass($class); $interface = 'Symfony\Component\EventDispatcher\EventSubscriberInterface'; if (!$refClass->implementsInterface($interface)) { throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface)); } $definition->addMethodCall('addSubscriberService', array($id, $class)); } }
public function process(ContainerBuilder $container) { if (false === $container->hasDefinition('sms.sender') || false === $container->hasAlias('sms.pool')) { return; } $delayedDefinition = new Definition($container->getParameter('sms.delayed_sender.class'), array($container->getDefinition('sms.sender'), new Reference('sms.pool'))); $container->setDefinition('sms.sender', $delayedDefinition); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasAlias('oauth2_server.refresh_token.manager')) { return; } $definition = $container->getDefinition('oauth2_server.token_endpoint'); $definition->addMethodCall('enabledRefreshTokenSupport', [new Reference('oauth2_server.refresh_token.manager')]); }
public function testProcess() { $builder = new ContainerBuilder(); $builder->setParameter(ModeraBackendSecurityExtension::CONFIG_KEY, array('mail_service' => 'some_service_id')); $this->assertFalse($builder->hasAlias('modera_backend_security.service.mail_service')); $cp = new ServiceAliasCompilerPass(); $cp->process($builder); $this->assertEquals('some_service_id', $builder->getAlias('modera_backend_security.service.mail_service')); }
public function testProcess() { $builder = new ContainerBuilder(); $builder->setParameter(ModeraActivityLoggerExtension::CONFIG_KEY, array('activity_manager' => 'some_service_id')); $this->assertFalse($builder->hasAlias('modera_activity_logger.manager.activity_manager')); $cp = new ServiceAliasCompilerPass(); $cp->process($builder); $this->assertEquals('some_service_id', $builder->getAlias('modera_activity_logger.manager.activity_manager')); }
public function process(ContainerBuilder $container) { if (!$container->hasAlias('security.acl.provider') && !$container->hasDefinition('security.acl.provider')) { $container->removeDefinition('security.acl.permission_evaluator'); } if ($container->hasDefinition('security.role_hierarchy')) { $container->getDefinition('security.role_hierarchy')->setPublic(true); } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $default_backend = $container->hasParameter('default_backend') ? $container->getParameter('default_backend') : NULL; // No default backend was configured, so continue as normal. if (!isset($default_backend)) { return; } foreach ($container->findTaggedServiceIds('backend_overridable') as $id => $attributes) { // If the service is already an alias it is not the original backend, so // we don't want to fallback to other storages any longer. if ($container->hasAlias($id)) { continue; } if ($container->hasDefinition("{$default_backend}.{$id}") || $container->hasAlias("{$default_backend}.{$id}")) { $container->setAlias($id, new Alias("{$default_backend}.{$id}")); } } }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition($this->enrichingStreamDecoratorServiceId) && !$container->hasAlias($this->enrichingStreamDecoratorServiceId)) { throw new RuntimeException(sprintf('Unknown Stream Decorator service known as %s', $this->enrichingStreamDecoratorServiceId)); } $definition = $container->findDefinition($this->enrichingStreamDecoratorServiceId); foreach ($container->findTaggedServiceIds($this->enricherTag) as $id => $attributes) { $definition->addMethodCall('registerEnricher', array(new Reference($id))); } }
/** * Returns the definition of the provided service. * * This method also resolves aliases. * * @param ContainerBuilder $container * @param string $id * @return \Symfony\Component\DependencyInjection\Definition|null */ protected function getDefinition(ContainerBuilder $container, $id) { while ($container->hasAlias($id)) { $id = (string) $container->getAlias($id); } if (!$container->hasDefinition($id)) { return null; } return $container->getDefinition($id); }
/** * {@inheritDoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition($this->eventDispatcherId) && !$container->hasAlias($this->eventDispatcherId)) { throw new RuntimeException(sprintf('Unknown Event Dispatcher service known as %s', $this->eventDispatcherId)); } $definition = $container->findDefinition($this->eventDispatcherId); foreach ($container->findTaggedServiceIds($this->serviceTag) as $id => $attributes) { $this->processListenerDefinition($container, $definition, $id); } }