Sets a service definition.
|
public setDefinition ( string $id, |
||
| $id | string | The service identifier |
| $definition | A Definition instance | |
| return | the service definition | |
public function load(array $configs, ContainerBuilder $container)
{
$xml = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$xml->load('services.xml');
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
foreach ($configs as $subConfig) {
$config = array_merge($config, $subConfig);
}
$definition = $container->getDefinition('goetas_webservices.xsd2php.naming_convention.' . $config['naming_strategy']);
$container->setDefinition('goetas_webservices.xsd2php.naming_convention', $definition);
$schemaReader = $container->getDefinition('goetas_webservices.xsd2php.schema_reader');
foreach ($config['known_locations'] as $namespace => $location) {
$schemaReader->addMethodCall('addKnownSchemaLocation', [$namespace, $location]);
}
foreach (['php', 'jms'] as $type) {
$definition = $container->getDefinition('goetas_webservices.xsd2php.path_generator.' . $type . '.' . $config['path_generator']);
$container->setDefinition('goetas_webservices.xsd2php.path_generator.' . $type, $definition);
$pathGenerator = $container->getDefinition('goetas_webservices.xsd2php.path_generator.' . $type);
$pathGenerator->addMethodCall('setTargets', [$config['destinations_' . $type]]);
$converter = $container->getDefinition('goetas_webservices.xsd2php.converter.' . $type);
foreach ($config['namespaces'] as $xml => $php) {
$converter->addMethodCall('addNamespace', [$xml, self::sanitizePhp($php)]);
}
foreach ($config['aliases'] as $xml => $data) {
foreach ($data as $type => $php) {
$converter->addMethodCall('addAliasMapType', [$xml, $type, self::sanitizePhp($php)]);
}
}
}
$container->setParameter('goetas_webservices.xsd2php.config', $config);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$container->setParameter('eo_airbrake.api_key', $config['api_key']);
$container->setParameter('eo_airbrake.async', $config['async']);
$container->setParameter('eo_airbrake.host', $config['host']);
$container->setParameter('eo_airbrake.secure', $config['secure']);
// Exception Listener
if ($config['api_key']) {
// Airbreak Configuration
$class = $container->getParameter('eo_airbrake.configuration.class');
$definition = new Definition($class, array($config['api_key'], $config['async'], $container->getParameter('kernel.environment'), $config['host'], $config['secure']));
$container->setDefinition('eo_airbrake.configuration', $definition);
// Airbreak Client
$class = $container->getParameter('eo_airbrake.client.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.configuration')));
$container->setDefinition('eo_airbrake.client', $definition);
// Exception Listener
$class = $container->getParameter('eo_airbrake.exception_listener.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.client'), $config['ignored_exceptions']));
$definition->addTag('kernel.event_listener', array('event' => 'kernel.exception', 'method' => 'onKernelException'));
$container->setDefinition('php_airbrake.exception_listener', $definition);
// PHP Shutdown Listener
$class = $container->getParameter('eo_airbrake.shutdown_listener.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.client')));
$definition->addTag('kernel.event_listener', array('event' => 'kernel.controller', 'method' => 'register'));
$container->setDefinition('php_airbrake.shutdown_listener', $definition);
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$analysis = $container->getParameter('es.analysis');
$connections = $container->getParameter('es.connections');
$managers = $container->getParameter('es.managers');
$collector = $container->get('es.metadata_collector');
foreach ($managers as $managerName => $manager) {
if (!isset($connections[$manager['connection']])) {
throw new InvalidConfigurationException('There is no ES connection with the name: ' . $manager['connection']);
}
$managerName = strtolower($managerName);
$connection = $connections[$manager['connection']];
$managerDefinition = new Definition($container->getParameter('es.manager.class'), [$managerName, $connection, $analysis, $manager]);
$managerDefinition->setFactory([new Reference('es.manager_factory'), 'createManager']);
$container->setDefinition(sprintf('es.manager.%s', $managerName), $managerDefinition);
// Make es.manager.default as es.manager service.
if ($managerName === 'default') {
$container->setAlias('es.manager', 'es.manager.default');
}
$mappings = $collector->getMappings($manager['mappings']);
// Building repository services.
foreach ($mappings as $repositoryType => $repositoryDetails) {
$repositoryDefinition = new Definition($container->getParameter('es.repository.class'), [$repositoryDetails['bundle'] . ':' . $repositoryDetails['class']]);
$repositoryDefinition->setFactory([new Reference(sprintf('es.manager.%s', $managerName)), 'getRepository']);
$repositoryId = sprintf('es.manager.%s.%s', $managerName, $repositoryType);
if (strtolower(substr($repositoryType, -8)) === 'document') {
$container->setAlias(sprintf('es.manager.%s.%s', $managerName, substr($repositoryType, 0, strlen($repositoryType) - 8)), $repositoryId);
}
$container->setDefinition($repositoryId, $repositoryDefinition);
}
}
}
public function process(ContainerBuilder $container)
{
if (!($container->hasDefinition('fragment.listener') && $container->hasDefinition('ezpublish.decorated_fragment_renderer'))) {
return null;
}
$fragmentListenerDef = $container->findDefinition('fragment.listener');
$fragmentListenerDef->setFactoryService('ezpublish.fragment_listener.factory')->setFactoryMethod('buildFragmentListener')->addArgument('%fragment.listener.class%');
// Looping over all fragment renderers to decorate them
// This is to make sure they are siteaccess aware (siteaccess is serialized in rendered path).
foreach ($container->findTaggedServiceIds('kernel.fragment_renderer') as $id => $attributes) {
$renamedId = "{$id}.inner";
$definition = $container->getDefinition($id);
$public = $definition->isPublic();
$tags = $definition->getTags();
$definition->setPublic(false);
$container->setDefinition($renamedId, $definition);
$decoratedDef = new DefinitionDecorator('ezpublish.decorated_fragment_renderer');
$decoratedDef->setArguments(array(new Reference($renamedId)));
$decoratedDef->setPublic($public);
$decoratedDef->setTags($tags);
// Special treatment for inline fragment renderer, to fit ESI renderer constructor type hinting (forced to InlineFragmentRenderer)
if ($id === 'fragment.renderer.inline') {
$decoratedDef->setClass($container->getParameter('ezpublish.decorated_fragment_renderer.inline.class'));
}
$container->setDefinition($id, $decoratedDef);
}
}
private function createAndRegisterDefinitions(array $config = array())
{
foreach ($config as $commandName => $commandOptions) {
$definition = $this->generateCommandDefinition($commandName, $commandOptions);
$this->container->setDefinition('phpzone.shell.' . $commandName, $definition);
}
}
protected function loadManagers($config, ContainerBuilder $container)
{
$baseDefinition = $container->getDefinition('kcs.api_connector.request_manager.abstract');
foreach ($config as $name => $managerConfig) {
$definition = clone $baseDefinition;
$definition->setAbstract(false);
switch ($managerConfig['transport']) {
case 'guzzle':
$definition->replaceArgument(0, new Reference('kcs.api_connector.guzzle_transport'));
break;
case 'custom':
$service_name = 'kcs.api_connector.custom_transport.' . $name;
$transport_definition = new Definition($managerConfig['transport_class']);
$container->setDefinition($service_name, $transport_definition);
$definition->replaceArgument(0, new Reference($service_name));
}
$definition->replaceArgument(2, $managerConfig['base_url']);
$auth = isset($managerConfig['authenticator']) ? $managerConfig['authenticator'] : AnonymousAuthenticator::class;
if (!class_exists($auth)) {
$auth = new Reference($auth);
}
$definition->addMethodCall('setDefaultAuthenticator', [$auth]);
$container->setDefinition('kcs.api_connector.request_manager.' . $name, $definition);
}
}
private function createBusDefinition($id, $priority)
{
$definition = new Definition('stdClass');
$definition->addTag($this->middlewareTag, array('priority' => $priority));
$this->container->setDefinition($id, $definition);
return $definition;
}
/**
* You can modify the container here before it is dumped to PHP code.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
// get applications configuration array
$applications = $container->getParameter(DreamCommerceShopAppstoreExtension::ALIAS . '.apps');
// create definition for application registry
$applicationsDefinition = new Definition('DreamCommerce\\ShopAppstoreBundle\\Handler\\ApplicationRegistry');
// configuration for every app
foreach ($applications as $app => $data) {
$definition = new Definition('DreamCommerce\\ShopAppstoreBundle\\Handler\\Application');
$definition->addArgument($app);
$definition->addArgument($data['app_id']);
$definition->addArgument($data['app_secret']);
$definition->addArgument($data['appstore_secret']);
// if logger is instantiated, use it
$definition->addArgument(new Reference(DreamCommerceShopAppstoreExtension::ALIAS . '.logger', ContainerInterface::NULL_ON_INVALID_REFERENCE));
// ignore SSL errors?
$definition->addArgument($container->getParameter(DreamCommerceShopAppstoreExtension::ALIAS . '.skip_ssl'));
// application version
$definition->addArgument($data['minimal_version']);
// user agent, todo: make calls consistent, eg. logger argument -> call like this
$definition->addMethodCall('setUserAgent', [$data['user_agent']]);
// defined application webhooks configuration
$definition->addMethodCall('setWebhooks', [$data['webhooks']]);
$app = DreamCommerceShopAppstoreExtension::ALIAS . '.app.' . $app;
// append definition
$container->setDefinition($app, $definition);
// add application to the registry
$applicationsDefinition->addMethodCall('register', array(new Reference($app)));
}
// append applications registry to the container
$container->setDefinition(DreamCommerceShopAppstoreExtension::ALIAS . '.apps', $applicationsDefinition);
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
if ($config['cache']) {
$container->setAlias('vesax.seo.metadata_cache', 'doctrine_cache.providers.' . $config['cache']);
}
if ($config['redirects']['enabled']) {
$container->setDefinition('vesax.seo.redirect_matcher', new Definition('Vesax\\SEOBundle\\Matcher\\RedirectRuleMatcher'));
$redirectListenerDefinition = new Definition('Vesax\\SEOBundle\\EventListener\\RedirectListener', [new Reference('vesax.seo.redirect_rule_repository'), new Reference('vesax.seo.redirect_matcher'), new Reference('vesax.seo.metadata_cache', ContainerInterface::NULL_ON_INVALID_REFERENCE)]);
$redirectListenerDefinition->addTag('kernel.event_listener', ['event' => 'kernel.exception', 'method' => 'onException']);
if (!$config['redirects']['not_found_only']) {
$redirectListenerDefinition->addTag('kernel.event_listener', ['event' => 'kernel.request', 'method' => 'onRequest', 'priority' => 99]);
}
$container->setDefinition('vesax.seo.redirect_listener', $redirectListenerDefinition);
$redirectAdminDefinition = new Definition('Vesax\\SEOBundle\\Admin\\RedirectRuleAdmin', [null, "Vesax\\SEOBundle\\Entity\\RedirectRule", "SonataAdminBundle:CRUD"]);
$redirectAdminDefinition->addTag('sonata.admin', ['manager_type' => 'orm', 'group' => 'SEO', 'label' => 'Redirect Rules']);
$container->setDefinition('vesax.seo.admin.rediect_rule', $redirectAdminDefinition);
}
if ($config['robots']) {
$menuListenerDefinition = new Definition('Vesax\\SEOBundle\\EventListener\\ConfigureAdminMenuListener');
$menuListenerDefinition->addTag('kernel.event_listener', ['event' => 'sonata.admin.event.configure.menu.sidebar', 'method' => 'configureMenu']);
$container->setDefinition('vesax.seo.admin.menu_listener', $menuListenerDefinition);
}
if ($config['meta']) {
$metaAdminDefinition = new Definition('Vesax\\SEOBundle\\Admin\\RuleAdmin', [null, Rule::class, 'SonataAdminBundle:CRUD']);
$metaAdminDefinition->addTag('sonata.admin', ['manager_type' => 'orm', 'group' => 'SEO', 'label' => 'Page Rules']);
$container->setDefinition('vesax.seo.admin.rule', $metaAdminDefinition);
}
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
}
/**
* Returns a definition for an asset package.
*
* @param ContainerBuilder $container Container
* @param array $httpUrls SSL assets_base_urls
* @param array $sslUrls assets_base_urls
* @param string $rootDir Directory where to look for reved assets
* @param string $summaryFile Grunt filerev summary file
* @param string $cacheDir Kernel cache dir
* @param bool $debug Debug mode?
* @param string $name Package name
*
* @return DefinitionDecorator
*/
private function createPackageDefinition(ContainerBuilder $container, array $httpUrls, array $sslUrls, $rootDir, $summaryFile, $cacheDir, $debug, $name = null)
{
if (!$httpUrls) {
$package = new DefinitionDecorator('grunt.filerev.templating.asset.path_package');
$package->setPublic(false)->setScope('request')->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
return $package;
}
if ($httpUrls == $sslUrls) {
$package = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$package->setPublic(false)->replaceArgument(0, $sslUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
return $package;
}
$prefix = $name ? 'templating.asset.package.' . $name : 'templating.asset.default_package';
$httpPackage = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$httpPackage->replaceArgument(0, $httpUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
$container->setDefinition($prefix . '.http', $httpPackage);
if ($sslUrls) {
$sslPackage = new DefinitionDecorator('grunt.filerev.templating.asset.url_package');
$sslPackage->replaceArgument(0, $sslUrls)->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
} else {
$sslPackage = new DefinitionDecorator('grunt.filerev.templating.asset.path_package');
$sslPackage->setScope('request')->replaceArgument(1, $rootDir)->replaceArgument(2, $summaryFile)->replaceArgument(3, $cacheDir)->replaceArgument(4, $debug);
}
$container->setDefinition($prefix . '.ssl', $sslPackage);
$package = new DefinitionDecorator('templating.asset.request_aware_package');
$package->setPublic(false)->setScope('request')->replaceArgument(1, $prefix . '.http')->replaceArgument(2, $prefix . '.ssl');
return $package;
}
public function testConfigure()
{
$prevDumper = $this->getDumpHandler();
$container = new ContainerBuilder();
$container->setDefinition('var_dumper.cloner', new Definition('Symfony\\Component\\HttpKernel\\Tests\\EventListener\\MockCloner'));
$container->setDefinition('mock_dumper', new Definition('Symfony\\Component\\HttpKernel\\Tests\\EventListener\\MockDumper'));
ob_start();
$exception = null;
$listener = new DumpListener($container, 'mock_dumper');
try {
$listener->configure();
$lazyDumper = $this->getDumpHandler();
VarDumper::dump('foo');
$loadedDumper = $this->getDumpHandler();
VarDumper::dump('bar');
$this->assertSame('+foo-+bar-', ob_get_clean());
$listenerReflector = new \ReflectionClass($listener);
$lazyReflector = new \ReflectionFunction($lazyDumper);
$loadedReflector = new \ReflectionFunction($loadedDumper);
$this->assertSame($listenerReflector->getFilename(), $lazyReflector->getFilename());
$this->assertSame($listenerReflector->getFilename(), $loadedReflector->getFilename());
$this->assertGreaterThan($lazyReflector->getStartLine(), $loadedReflector->getStartLine());
} catch (\Exception $exception) {
}
VarDumper::setHandler($prevDumper);
if (null !== $exception) {
throw $exception;
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
foreach ($config['renderer'] as $rendererName => $rendererConfiguration) {
switch ($rendererConfiguration['type']) {
default:
// case native
$class = 'Avisota\\Renderer\\NativeMessageRenderer';
$args = array();
}
$definition = new Definition($class, $args);
$container->setDefinition('avisota.renderer.' . $rendererName, $definition);
}
foreach ($config['queue'] as $queueName => $queueConfiguration) {
switch ($queueConfiguration['type']) {
default:
// case simple
$class = 'Avisota\\Queue\\SimpleDatabaseQueue';
$args = array(new Reference('doctrine.dbal.default_connection'), $queueConfiguration['table']);
}
$definition = new Definition($class, $args);
$container->setDefinition('avisota.queue.' . $queueName, $definition);
}
foreach ($config['transport'] as $transportName => $transportConfiguration) {
switch ($transportConfiguration['type']) {
default:
// case swift
$class = 'Avisota\\Transport\\SwiftTransport';
$args = array(new Reference($transportConfiguration['id']), new Reference('avisota.renderer.' . $transportConfiguration['renderer']));
}
$definition = new Definition($class, $args);
$container->setDefinition('avisota.transport.' . $transportName, $definition);
}
}
/**
* Creates a new Guzzle client definition
*
* @param string $name Client name
* @param array $config Client configuration
* @param ContainerBuilder $container Service container
*
* @throws \LogicException
*/
private function newGuzzleClient($name, array $config, ContainerBuilder $container)
{
$client = new Definition('Guzzle\\Service\\Description\\ServiceDescription');
$client->setFactory(['Guzzle\\Service\\Description\\ServiceDescription', 'factory']);
if (!isset($config['description']['name'])) {
$config['description']['name'] = $name;
}
$client->addArgument($config['description']);
// Add the service to the container
$serviceName = sprintf('lsw_guzzle.%s', $name);
$container->setDefinition($serviceName, $client);
$client = new Definition('Guzzle\\Service\\Client');
$client->setFactory(['Guzzle\\Service\\Client', 'factory']);
$client->addArgument($config['config']);
$client->addMethodCall('setDescription', array(new Reference($serviceName)));
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.log_plugin')));
if (isset($config['config']['json_objects']) && $config['config']['json_objects']) {
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.json_objects_plugin')));
}
if ($container->hasDefinition('lsw_guzzle.command_history_plugin')) {
$client->addMethodCall('addSubscriber', array(new Reference('lsw_guzzle.command_history_plugin')));
}
// Add the service to the container
$serviceName = sprintf('guzzle.%s', $name);
$container->setDefinition($serviceName, $client);
}
protected function handleConfiguration($config, ContainerBuilder $container)
{
if (!isset($config['features'])) {
return;
}
if (!$container->hasDefinition('hotflo_feature_toggle.feature_container')) {
return;
}
$featureToggleContainerDefinition = $container->findDefinition('hotflo_feature_toggle.feature_toggle_container');
foreach ($config['toggles'] as $toggle => $properties) {
if ($properties['type'] == 'service') {
$container->setAlias('hotflo_feature_toggle.toggle.' . $toggle, $properties['service']);
} else {
if (!class_exists($properties['class'])) {
throw new InvalidConfigurationException(sprintf('Class \'%s\' not found.', $properties['class']));
}
$toggleDefinition = new Definition($properties['class']);
$toggleDefinition->addArgument($properties['options']);
$container->setDefinition('hotflo_feature_toggle.toggle.' . $toggle, $toggleDefinition);
}
$featureToggleContainerDefinition->addMethodCall('addFeatureToggle', [new Reference('hotflo_feature_toggle.toggle.' . $toggle), $toggle]);
}
$featureContainerDefinition = $container->findDefinition('hotflo_feature_toggle.feature_container');
foreach ($config['features'] as $feature => $properties) {
$featureDefinition = new Definition('JoshuaEstes\\Component\\FeatureToggle\\Feature');
$featureDefinition->addArgument($properties['options']);
$featureDefinition->addMethodCall('setKey', [$feature]);
$featureDefinition->addMethodCall('setToggle', [new Reference('hotflo_feature_toggle.toggle.' . $properties['toggle'])]);
$container->setDefinition('hotflo_feature_toggle.feature.' . $feature, $featureDefinition);
$featureContainerDefinition->addMethodCall('addFeature', [new Reference('hotflo_feature_toggle.feature.' . $feature)]);
}
}
public function process(ContainerBuilder $container)
{
// log
$definition = $container->findDefinition('csa_guzzle.subscriber.log');
$logServiceId = $container->getParameter('csa_guzzle.subscriber.log.service');
if ($container->hasDefinition($logServiceId)) {
$definition->replaceArgument(0, new Reference($logServiceId));
}
$channel = $container->getParameter('csa_guzzle.subscriber.log.channel');
if (!empty($channel)) {
$definition->clearTag('monolog.logger');
$definition->addTag('monolog.logger', array('channel' => $channel));
}
// Cache
$cacheServiceId = $container->getParameter('csa_guzzle.subscriber.cache.service');
if ($container->hasDefinition($cacheServiceId)) {
$container->setDefinition('csa_guzzle.cache_storage', new Definition('%csa_guzzle.cache_storage.class%', array(new Reference($cacheServiceId), $container->getParameter('csa_guzzle.subscriber.cache.prefix'))));
$cacheSubscriber = new Definition('%csa_guzzle.subscriber.cache.class%', array(new Reference('csa_guzzle.cache_storage'), $container->getParameter('csa_guzzle.subscriber.cache.enable')));
$cacheSubscriber->addTag('csa_guzzle.subscriber');
$container->setDefinition('csa_guzzle.subscriber.cache', $cacheSubscriber);
}
// get all Guzzle subscribers
$subscribers = $container->findTaggedServiceIds('csa_guzzle.subscriber');
if (!count($subscribers)) {
return;
}
// Factory
$factory = $container->findDefinition('csa_guzzle.client_factory');
$arg = [];
foreach ($subscribers as $subscriber => $options) {
$arg[] = new Reference($subscriber);
}
$factory->replaceArgument(1, $arg);
}
/**
* Creates needed search services for given connection name and parameters.
*
* @param ContainerBuilder $container
* @param string $connectionName
* @param array $connectionParams
*/
private function configureSearchServices(ContainerBuilder $container, $connectionName, $connectionParams)
{
$alias = $this->getAlias();
// Http client
$httpClientId = static::HTTP_CLIENT_ID . ".{$connectionName}";
$httpClientDef = new DefinitionDecorator(self::HTTP_CLIENT_ID);
$httpClientDef->replaceArgument(0, $connectionParams['server']);
$container->setDefinition($httpClientId, $httpClientDef);
// Content search gateway
$contentSearchGatewayDef = new DefinitionDecorator(self::CONTENT_SEARCH_GATEWAY_ID);
$contentSearchGatewayDef->replaceArgument(0, new Reference($httpClientId));
$contentSearchGatewayDef->replaceArgument(5, $connectionParams['index_name']);
$contentSearchGatewayId = self::CONTENT_SEARCH_GATEWAY_ID . ".{$connectionName}";
$container->setDefinition($contentSearchGatewayId, $contentSearchGatewayDef);
// Location search gateway
$locationSearchGatewayDef = new DefinitionDecorator(self::LOCATION_SEARCH_GATEWAY_ID);
$locationSearchGatewayDef->replaceArgument(0, new Reference($httpClientId));
$locationSearchGatewayDef->replaceArgument(5, $connectionParams['index_name']);
$locationSearchGatewayId = self::LOCATION_SEARCH_GATEWAY_ID . ".{$connectionName}";
$container->setDefinition($locationSearchGatewayId, $locationSearchGatewayDef);
// Search handler
$searchEngineDef = new DefinitionDecorator(self::MAIN_SEARCH_ENGINE_ID);
$searchEngineDef->replaceArgument(0, new Reference($contentSearchGatewayId));
$searchEngineDef->replaceArgument(1, new Reference($locationSearchGatewayId));
$searchEngineDef->replaceArgument(4, $connectionParams['document_type_name']['content']);
$searchEngineDef->replaceArgument(5, $connectionParams['document_type_name']['location']);
$searchEngineId = self::MAIN_SEARCH_ENGINE_ID . ".{$connectionName}";
$container->setDefinition($searchEngineId, $searchEngineDef);
$container->setParameter("{$alias}.connection.{$connectionName}.engine_id", $searchEngineId);
}
public function testProcess()
{
// TEST 1
// must work with no tagged services
$containerBuilder = new ContainerBuilder();
$compilerPass = new RepositoryCompilerPass();
$compilerPass->process($containerBuilder);
// TEST 2
// must add repository tagged service into the repository pool
$containerBuilder = new ContainerBuilder();
$containerBuilder->setDefinition('lag.repository.repository_pool', new Definition());
$repository = new Definition();
$repository->addTag('doctrine.repository');
$containerBuilder->setDefinition('repository1', $repository);
$repository = new Definition();
$repository->addTag('doctrine.repository');
$containerBuilder->setDefinition('repository2', $repository);
$compilerPass = new RepositoryCompilerPass();
$compilerPass->process($containerBuilder);
$methodCalls = $containerBuilder->getDefinition('lag.repository.repository_pool')->getMethodCalls();
$this->assertCount(2, $methodCalls);
foreach ($methodCalls as $call) {
/** @var Reference $reference */
$reference = $call[1][0];
// test reference assignment
$this->assertEquals('add', $call[0]);
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $reference);
$this->assertTrue(in_array($reference->__toString(), ['repository1', 'repository2']));
}
}
private function createFilesystem($name, array $config, ContainerBuilder $container, array $adapters, array $caches)
{
if (!array_key_exists($config['adapter'], $adapters)) {
throw new \LogicException(sprintf('The adapter \'%s\' is not defined.', $config['adapter']));
}
$adapter = $adapters[$config['adapter']];
$id = sprintf('oneup_flysystem.%s_filesystem', $name);
$cache = null;
if (array_key_exists($config['cache'], $caches)) {
$cache = $caches[$config['cache']];
$container->setDefinition($adapter . '_cached', new DefinitionDecorator('oneup_flysystem.adapter.cached'))->replaceArgument(0, new Reference($adapter))->replaceArgument(1, new Reference($cache));
}
$tagParams = array('key' => $name);
if ($config['mount']) {
$tagParams['mount'] = $config['mount'];
}
$options = [];
if (array_key_exists('visibility', $config)) {
$options['visibility'] = $config['visibility'];
}
$container->setDefinition($id, new DefinitionDecorator('oneup_flysystem.filesystem'))->replaceArgument(0, new Reference($cache ? $adapter . '_cached' : $adapter))->replaceArgument(1, $options)->addTag('oneup_flysystem.filesystem', $tagParams);
if (!empty($config['alias'])) {
$container->getDefinition($id)->setPublic(false);
$container->setAlias($config['alias'], $id);
}
// Attach Plugins
$defFilesystem = $container->getDefinition($id);
if (isset($config['plugins']) && is_array($config['plugins'])) {
foreach ($config['plugins'] as $pluginId) {
$defFilesystem->addMethodCall('addPlugin', array(new Reference($pluginId)));
}
}
return new Reference($id);
}
/**
* @dataProvider processProvider
*/
public function testProcess($hasWarmer, $configIds)
{
$warmerId = 'yahoo_japan_config_cache.cache_warmer';
$container = new ContainerBuilder();
foreach ($configIds as $configId) {
$definition = new Definition($configId);
$definition->addTag(ConfigCache::TAG_CACHE_WARMER);
$container->setDefinition($configId, $definition);
}
if ($hasWarmer) {
$definition = new Definition($warmerId);
$container->setDefinition($warmerId, $definition);
}
$pass = new CacheWarmerPass();
$pass->process($container);
foreach ($configIds as $index => $configId) {
if ($hasWarmer) {
$calls = $container->getDefinition($warmerId)->getMethodCalls();
$this->assertTrue(isset($calls[$index][0]));
// method name
$this->assertSame('addConfig', $calls[$index][0]);
$this->assertTrue(isset($calls[$index][1][0]));
// argument
$this->assertEquals(new Reference($configId), $calls[$index][1][0]);
} else {
$this->assertFalse($container->hasDefinition($warmerId));
}
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
if ($container->hasDefinition('doctrine')) {
$definition = new DefinitionDecorator('dag.form.type.object_to_identifier');
$definition->addArgument(new Reference('doctrine'));
$definition->addArgument('dag_entity_to_identifier');
$definition->addTag('form.type', array('alias' => 'dag_entity_to_identifier'));
$container->setDefinition('dag_entity_to_identifier', $definition);
}
if ($container->hasDefinition('doctrine_mongodb')) {
$definition = new DefinitionDecorator('dag.form.type.object_to_identifier');
$definition->addArgument(new Reference('doctrine_mongodb'));
$definition->addArgument('dag_document_to_identifier');
$definition->addTag('form.type', array('alias' => 'dag_document_to_identifier'));
$container->setDefinition('dag_document_to_identifier', $definition);
if (!$container->hasDefinition('dag_entity_to_identifier')) {
$container->setAlias('dag_entity_to_identifier', 'dag_document_to_identifier');
}
}
if ($container->hasDefinition('doctrine_phpcr')) {
$definition = new DefinitionDecorator('dag.form.type.object_to_identifier');
$definition->addArgument(new Reference('doctrine_phpcr'));
$definition->addArgument('dag_phpcr_document_to_identifier');
$definition->addTag('form.type', array('alias' => 'dag_phpcr_document_to_identifier'));
$container->setDefinition('dag_phpcr_document_to_identifier', $definition);
if (!$container->hasDefinition('dag_entity_to_identifier')) {
$container->setAlias('dag_entity_to_identifier', 'dag_phpcr_document_to_identifier');
}
}
}
/**
* Configure the sitemap source manager.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function configureSitemap(array $config, ContainerBuilder $container)
{
$source = $container->getDefinition('sonata.seo.sitemap.manager');
if (method_exists($source, 'setShared')) {
// Symfony 2.8+
$source->setShared(false);
} else {
// For Symfony <2.8 compatibility
$source->setScope(ContainerInterface::SCOPE_PROTOTYPE);
}
foreach ($config['doctrine_orm'] as $pos => $sitemap) {
// define the connectionIterator
$connectionIteratorId = 'sonata.seo.source.doctrine_connection_iterator_' . $pos;
$connectionIterator = new Definition('%sonata.seo.exporter.database_source_iterator.class%', array(new Reference($sitemap['connection']), $sitemap['query']));
$connectionIterator->setPublic(false);
$container->setDefinition($connectionIteratorId, $connectionIterator);
// define the sitemap proxy iterator
$sitemapIteratorId = 'sonata.seo.source.doctrine_sitemap_iterator_' . $pos;
$sitemapIterator = new Definition('%sonata.seo.exporter.sitemap_source_iterator.class%', array(new Reference($connectionIteratorId), new Reference('router'), $sitemap['route'], $sitemap['parameters']));
$sitemapIterator->setPublic(false);
$container->setDefinition($sitemapIteratorId, $sitemapIterator);
$source->addMethodCall('addSource', array($sitemap['group'], new Reference($sitemapIteratorId), $sitemap['types']));
}
foreach ($config['services'] as $service) {
$source->addMethodCall('addSource', array($service['group'], new Reference($service['id']), $service['types']));
}
}
/**
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
* @param $code
* @param \Symfony\Component\DependencyInjection\Definition $formatter
* @param array $extensions
*
* @return string
*/
public function createEnvironment(ContainerBuilder $container, $code, Definition $formatter, array $extensions)
{
$loader = new Definition('Twig_Loader_String');
$loader->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.loader.%s', $code), $loader);
$loaderSelector = new Definition('Sonata\\FormatterBundle\\Twig\\Loader\\LoaderSelector', array(new Reference(sprintf('sonata.formatter.twig.loader.%s', $code)), new Reference('twig.loader')));
$loaderSelector->setPublic(false);
$env = new Definition('Twig_Environment', array($loaderSelector, array('debug' => false, 'strict_variables' => false, 'charset' => 'UTF-8')));
$env->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.env.%s', $code), $env);
$sandboxPolicy = new Definition('Sonata\\FormatterBundle\\Twig\\SecurityPolicyContainerAware', array(new Reference('service_container'), $extensions));
$sandboxPolicy->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s.policy', $code), $sandboxPolicy);
$sandbox = new Definition('Twig_Extension_Sandbox', array($sandboxPolicy, true));
$sandbox->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s', $code), $sandbox);
$env->addMethodCall('addExtension', array(new Reference(sprintf('sonata.formatter.twig.sandbox.%s', $code))));
foreach ($extensions as $extension) {
$env->addMethodCall('addExtension', array(new Reference($extension)));
}
$lexer = new Definition('Twig_Lexer', array(new Reference(sprintf('sonata.formatter.twig.env.%s', $code)), array('tag_comment' => array('<#', '#>'), 'tag_block' => array('<%', '%>'), 'tag_variable' => array('<%=', '%>'))));
$lexer->setPublic(false);
$container->setDefinition(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code)), $lexer);
$env->addMethodCall('setLexer', array(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code))));
return sprintf('sonata.formatter.twig.env.%s', $code);
}
private function getContainer()
{
$container = new ContainerBuilder();
$container->setDefinition('a', new Definition('Darsyn\\Bundle\\ServiceTemplatesBundle\\Test\\Fixtures\\A'));
$container->setDefinition('b', new Definition('Darsyn\\Bundle\\ServiceTemplatesBundle\\Test\\Fixtures\\B'));
return $container;
}
/**
* @return ContainerBuilder
*/
public static function createContainer($rootDir)
{
$container = new ContainerBuilder(new ParameterBag(array('kernel.root_dir' => $rootDir)));
// synthetic services
$container->setDefinition('autoloader', new Definition('Composer\\Autoload\\ClassLoader'))->setSynthetic(true);
$container->setDefinition('input_interface', new Definition('Symfony\\Component\\Console\\Input\\InputInterface'))->setSynthetic(true);
$container->setDefinition('output_interface', new Definition('Symfony\\Component\\Console\\Input\\InputInterface'))->setSynthetic(true);
$container->setDefinition('question_helper', new Definition('Symfony\\Component\\Console\\Helper\\QuestionHelper'))->setSynthetic(true);
$container->register('io_service', 'ShopwareCli\\Services\\IoService')->addArgument(new Reference('input_interface'))->addArgument(new Reference('output_interface'))->addArgument(new Reference('question_helper'));
$container->register('process_executor', 'ShopwareCli\\Services\\ProcessExecutor')->addArgument(new Reference('output_interface'))->addArgument(getenv('SW_TIMEOUT') ?: self::DEFAULT_PROCESS_TIMEOUT);
$container->register('git_identity_environment', 'ShopwareCli\\Services\\GitIdentityEnvironment')->addArgument(new Reference('path_provider'))->addArgument(new Reference('config'));
$container->register('git_util', 'ShopwareCli\\Services\\GitUtil')->addArgument(new Reference('output_interface'))->addArgument(new Reference('git_identity_environment'))->addArgument(getenv('SW_TIMEOUT') ?: self::DEFAULT_PROCESS_TIMEOUT);
$container->register('utilities', 'ShopwareCli\\Utilities')->addArgument(new Reference('io_service'));
$container->register('xdg', '\\XdgBaseDir\\Xdg');
$container->register('plugin_info', '\\Shopware\\PluginInfo\\PluginInfo');
$container->register('directory_gateway', 'ShopwareCli\\Services\\PathProvider\\DirectoryGateway\\XdgGateway')->addArgument(new Reference('xdg'));
$container->register('file_downloader', 'ShopwareCli\\Services\\StreamFileDownloader')->addArgument(new Reference('io_service'));
$container->register('path_provider', 'ShopwareCli\\Services\\PathProvider\\PathProvider')->addArgument(new Reference('directory_gateway'));
$container->register('cache', 'ShopwareCli\\Cache\\File')->addArgument($container->get('path_provider'));
$container->register('rest_service_factory', 'ShopwareCli\\Services\\Rest\\RestServiceFactory')->addArgument(new Reference('service_container'));
$container->register('config_file_collector', 'ShopwareCli\\ConfigFileCollector')->addArgument(new Reference('path_provider'));
$container->register('config', 'ShopwareCli\\Config')->addArgument(new Reference('config_file_collector'));
$container->register('extension_manager', 'ShopwareCli\\Application\\ExtensionManager')->addArgument(new Reference('autoloader'));
$container->register('command_manager', 'ShopwareCli\\Application\\CommandManager')->addArgument(new Reference('extension_manager'))->addArgument(new Reference('service_container'));
$container->register('openssl_verifier', 'ShopwareCli\\Services\\OpenSSLVerifier')->addArgument('%kernel.root_dir%/Resources/public.key');
$container->register('shopware_info', 'ShopwareCli\\Services\\ShopwareInfo');
return $container;
}
/**
* {@inheritdoc}
*/
public function load(ContainerBuilder $container, array $config)
{
$container->setDefinition(self::CLIENT_ID, new Definition('GuzzleHttp\\Client', [$config]));
$definition = new Definition('Ingresse\\Behat\\ApiExtension\\Context\\Initializer\\ApiClientInitializer', [new Reference(self::CLIENT_ID), $config]);
$definition->addTag(ContextExtension::INITIALIZER_TAG);
$container->setDefinition('ingresse_api.context_initializer', $definition);
}
/**
* @inheritDoc
*/
public function createServiceDefinitions(array $data, ContainerBuilder $container, $prefix)
{
if (!isset($data['host'])) {
throw new UrlResolveException("No host found in url");
}
$ssl = isset($data['ssl']) ? (bool) $data['ssl'] : false;
$port = $ssl ? 443 : 80;
if (isset($data['port'])) {
if (!ctype_digit($data['port'])) {
throw new UrlResolveException("Invalid port numer '{$data['port']}'");
}
$port = intval($data['port'], 10);
}
$host = $data['host'];
$protocol = $ssl ? 'https' : 'http';
$path = isset($data['path']) ? $data['path'] : '';
$settings = ['baseUri' => "{$protocol}://{$host}:{$port}/{$path}"];
if (isset($data['user'])) {
$settings['userName'] = $data['user'];
}
if (isset($data['pass'])) {
$settings['password'] = $data['pass'];
}
if (isset($data['proxy'])) {
$settings['proxy'] = $data['proxy'];
}
$adapterPrefix = null;
if (isset($data['prefix'])) {
$adapterPrefix = $data['prefix'];
}
$container->setDefinition("{$prefix}.client", new Definition('Sabre\\DAV\\Client', [$settings]));
$container->setDefinition("{$prefix}.adapter", new Definition('League\\Flysystem\\WebDAV\\WebDAVAdapter', [new Reference("{$prefix}.client"), $adapterPrefix]));
return "{$prefix}.adapter";
}
/**
* @var ContainerBuilder
* @return \Symfony\Component\DependencyInjection\ContainerBuilder
*/
public function createContainer()
{
$civicrm_base_path = dirname(dirname(__DIR__));
$container = new ContainerBuilder();
$container->setParameter('civicrm_base_path', $civicrm_base_path);
$container->set(self::SELF, $this);
// TODO Move configuration to an external file; define caching structure
// if (empty($configDirectories)) {
// throw new \Exception(__CLASS__ . ': Missing required properties (civicrmRoot, configDirectories)');
// }
// $locator = new FileLocator($configDirectories);
// $loaderResolver = new LoaderResolver(array(
// new YamlFileLoader($container, $locator)
// ));
// $delegatingLoader = new DelegatingLoader($loaderResolver);
// foreach (array('services.yml') as $file) {
// $yamlUserFiles = $locator->locate($file, NULL, FALSE);
// foreach ($yamlUserFiles as $file) {
// $delegatingLoader->load($file);
// }
// }
$container->setDefinition('angular', new Definition('\\Civi\\Angular\\Manager', array()))->setFactoryService(self::SELF)->setFactoryMethod('createAngularManager');
$container->setDefinition('dispatcher', new Definition('\\Symfony\\Component\\EventDispatcher\\EventDispatcher', array()))->setFactoryService(self::SELF)->setFactoryMethod('createEventDispatcher');
$container->setDefinition('magic_function_provider', new Definition('\\Civi\\API\\Provider\\MagicFunctionProvider', array()));
$container->setDefinition('civi_api_kernel', new Definition('\\Civi\\API\\Kernel', array(new Reference('dispatcher'), new Reference('magic_function_provider'))))->setFactoryService(self::SELF)->setFactoryMethod('createApiKernel');
// Expose legacy singletons as services in the container.
$singletons = array('resources' => 'CRM_Core_Resources', 'httpClient' => 'CRM_Utils_HttpClient');
foreach ($singletons as $name => $class) {
$container->setDefinition($name, new Definition($class))->setFactoryClass($class)->setFactoryMethod('singleton');
}
return $container;
}
/**
* Process the adaptor config configuration.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function loadConfigs(array $config, ContainerBuilder $container)
{
foreach ($config['configs'] as $name => $arguments) {
if (!$arguments['enabled']) {
continue;
}
$id = 'integrated_channel.config.memory.' . $name;
if ($container->hasDefinition($id)) {
continue;
}
// first create the options and for that we need a unique service id
do {
$id_options = $id . '.options.' . uniqid();
} while ($container->hasDefinition($id_options));
$definition = new Definition('%integrated_channel.config.options.class%');
$definition->setPublic(false);
$definition->setArguments([$arguments['options']]);
$container->setDefinition($id_options, $definition);
// create the config it self
$definition = new Definition('%integrated_channel.config.class%');
$definition->setArguments([$name, $arguments['adaptor'], new Reference($id_options)]);
if ($arguments['channel']) {
foreach ($arguments['channel'] as $channel) {
$definition->addTag('integrated_channel.config', ['channel' => $channel]);
}
} else {
$definition->addTag('integrated_channel.config');
}
$container->setDefinition($id, $definition);
}
}
/**
* {@inheritdoc}
*/
public function create(ContainerBuilder $container, $id, $config, $userProvider, $defaultEntryPoint)
{
// authentication provider
$authProviderId = 'oro_security.authentication.provider.organization_rememberme.' . $id;
$container->setDefinition($authProviderId, new DefinitionDecorator('oro_security.authentication.provider.organization_rememberme'))->addArgument($config['key'])->addArgument($id);
$templateId = 'oro_security.authentication.organization_rememberme.services.simplehash';
$rememberMeServicesId = $templateId . '.' . $id;
if ($container->hasDefinition('security.logout_listener.' . $id)) {
$container->getDefinition('security.logout_listener.' . $id)->addMethodCall('addHandler', array(new Reference($rememberMeServicesId)));
}
$rememberMeServices = $container->setDefinition($rememberMeServicesId, new DefinitionDecorator($templateId));
$rememberMeServices->replaceArgument(1, $config['key']);
$rememberMeServices->replaceArgument(2, $id);
if (isset($config['token_provider'])) {
$rememberMeServices->addMethodCall('setTokenProvider', array(new Reference($config['token_provider'])));
}
// remember-me options
$rememberMeServices->replaceArgument(3, array_intersect_key($config, $this->options));
// attach to remember-me aware listeners
$rememberMeServices->replaceArgument(0, $this->getUserProviders($container, $config, $id, $rememberMeServicesId));
// remember-me listener
$listenerId = 'oro_security.authentication.listener.organization_rememberme.' . $id;
$listener = $container->setDefinition($listenerId, new DefinitionDecorator('oro_security.authentication.listener.organization_rememberme'));
$listener->replaceArgument(1, new Reference($rememberMeServicesId));
return array($authProviderId, $listenerId, $defaultEntryPoint);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$loader->load('adapters.xml');
if ($config['limit']) {
$container->setParameter('chromedia_pager.pager.limit', $config['limit']);
}
if ($config['max_pages']) {
$container->setParameter('chromedia_pager.pager.max_pages', $config['max_pages']);
}
if ($config['template']) {
$container->setParameter('chromedia_pager.pager.template', $config['template']);
}
$pagerDef = $container->getDefinition('chromedia_pager.pager');
$pagerDef->replaceArgument(0, null);
// Add concrete pagers based on the same defintion (and defaults) as the main pager class
$doctrineOrmPagerDef = clone $pagerDef;
$doctrineOrmPagerDef->replaceArgument(0, new Reference('chromedia_pager.adapter.doctrine_orm'));
$container->setDefinition('chromedia_pager.doctrine_orm_pager', $doctrineOrmPagerDef);
$arrayPagerDef = clone $pagerDef;
$arrayPagerDef->replaceArgument(0, new Reference('chromedia_pager.adapter.array'));
$container->setDefinition('chromedia_pager.array_pager', $arrayPagerDef);
}
