/** * @param ContainerBuilder $container * @param string $code * @param 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); }
/** * @param string $name * @param array $config * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * * @return \Symfony\Component\DependencyInjection\Reference */ private function getConnectionReference($name, array $config, ContainerBuilder $container) { if (isset($config['connection_id'])) { return new Reference($config['connection_id']); } $host = $config['host']; $port = $config['port']; $connClass = '%doctrine_cache.redis.connection.class%'; $connId = sprintf('doctrine_cache.services.%s_redis.connection', $name); $connDef = new Definition($connClass); $connParams = array($host, $port); if (isset($config['timeout'])) { $connParams[] = $config['timeout']; } $connDef->setPublic(false); $connDef->addMethodCall('connect', $connParams); if (isset($config['password'])) { $password = $config['password']; $connDef->addMethodCall('auth', array($password)); } if (isset($config['database'])) { $database = (int) $config['database']; $connDef->addMethodCall('select', array($database)); } $container->setDefinition($connId, $connDef); return new Reference($connId); }
public function configureTemplate(ContainerBuilder $container, $configs) { $pageManager = $container->getDefinition('sonata.page.manager.page'); $snapshotManager = $container->getDefinition('sonata.page.manager.snapshot'); $defaults = array('name' => 'n-a', 'path' => 'SonataPageBundle::layout.html.twig'); if (!isset($configs['default_template'])) { $configs['default_template'] = 'default'; } if (!isset($configs['templates'])) { $configs['templates'] = array('default' => array_merge($defaults, array('name' => 'default'))); } $definitions = array(); foreach ($configs['templates'] as $code => $info) { $info = array_merge($defaults, $info); $definition = new Definition('Sonata\\PageBundle\\Model\\Template'); foreach ($defaults as $key => $value) { $method = 'set' . ucfirst($key); $definition->addMethodCall($method, array($info[$key])); } $definition->setPublic(false); $definitions[$code] = $definition; } $pageManager->addMethodCall('setTemplates', array($definitions)); $snapshotManager->addMethodCall('setTemplates', array($definitions)); $pageManager->addMethodCall('setDefaultTemplateCode', array($configs['default_template'])); }
public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); foreach ($config as $key => $value) { $container->setParameter('migrations' . '.' . $key, $value); } $loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $service = $container->getDefinition('migrations.migrator'); $migrationServices = []; foreach (new \DirectoryIterator($config['dir_name']) as $item) { if (!$item->isFile()) { continue; } $className = basename($item->getFilename(), '.php'); $migrationDefinition = new Definition($config['namespace'] . '\\' . $className); $migrationDefinition->setPublic(false); $migrationServices['migrations.migrations.' . strtolower($className)] = $migrationDefinition; } $container->addDefinitions($migrationServices); foreach (array_keys($migrationServices) as $id) { $service->addMethodCall('addMigration', [new Reference($id)]); } }
/** * @param Definition $definition */ protected function processDefinition(Definition $definition) { if ($definition->isSynthetic()) { return; } if ($definition->getFactoryService() || $definition->getFactoryClass()) { return; } if ($file = $definition->getFile()) { require_once $file; } if (!class_exists($definition->getClass())) { return; } $class = new \ReflectionClass($definition->getClass()); if (!$class->implementsInterface(static::INTERFACE_CLASS)) { return; } $metadata = $this->getMetadataFactory()->getMetadataForClass($definition->getClass()); if (!$metadata instanceof ClassMetadata) { return; } $namespace = $metadata->getNamespace() ?: static::ROOT_NAMESPACE; $serviceName = static::PROVIDER_PREFIX . substr(sha1($namespace), 0, 10); if (!$this->container->hasDefinition($serviceName)) { $cacher = new Definition('Werkint\\Bundle\\CacheBundle\\Service\\CacheProvider', [$this->container->getParameter('kernel.cache_dir') . '/werkint_cache']); $cacher->setPublic(true); $cacher->addMethodCall('setNamespace', [$namespace]); $this->container->setDefinition($serviceName, $cacher); } $definition->addMethodCall('setCacheProvider', [new Reference($serviceName)]); }
private function getDataCollectorDefinition() { $definition = new Definition(ApiClientDataCollector::class, [new Reference('leoza_api_client.profiler')]); $definition->setPublic(false); $definition->addTag('data_collector', ['template' => 'LeozaApiClientBundle:DataCollector:ApiClientProfile.html.twig', 'id' => 'leoza_api_client.data_collector']); return $definition; }
private function registerRequestBinder(ContainerBuilder $container) { $definition = new Definition(RequestObjectBinder::class, []); $definition->setAutowired(true); $definition->setPublic(false); $container->setDefinition('request_object.request_binder', $definition); }
/** * Registers publisher services in container */ protected function loadConnections() { foreach ($this->config['connections'] as $key => $connection) { $protocol = $connection['protocol']; $host = $connection['host']; $port = $connection['port']; $path = $connection['path']; $auth_key = $connection['auth_key']; $auth_secret = $connection['auth_secret']; $hostname = $connection['hostname']; $ignoreSsl = $connection['ssl_ignore']; if ($path[0] != '/') { $path = '/' . $path; } $definition = new Definition("Facile\\CrossbarHTTPPublisherBundle\\Publisher\\Factory", array($protocol, $host, $port, $path, $auth_key, $auth_secret, $hostname, $ignoreSsl)); $definition->setPublic(false); $factoryName = sprintf('facile.crossbar.publisher.factory.%s', $key); $this->container->setDefinition($factoryName, $definition); $definition = new Definition("Facile\\CrossbarHTTPPublisherBundle\\Publisher\\Publisher"); if (method_exists($definition, 'setFactory')) { $definition->setFactory(array(new Reference($factoryName), 'createPublisher')); } else { $definition->setFactoryService($factoryName); $definition->setFactoryMethod('createPublisher'); } $this->container->setDefinition(sprintf('facile.crossbar.publisher.%s', $key), $definition); } }
protected function addProvider($name, array $arguments = array()) { $provider = new Definition('%morbicer_converter.provider.' . $name . '.class%', $arguments); $provider->setPublic(false)->addTag('morbicer_converter.provider'); $this->container->setDefinition('morbicer_converter.provider.' . $name, $provider); return $provider; }
/** * Loads the Twig global variable. * * @param ContainerBuilder $container */ private function loadTwigExtension(ContainerBuilder $container) { $service = new Definition('EmanueleMinotto\\FakerBundle\\Twig\\FakerGeneratorExtension', array(new Reference('faker'))); $service->addTag('twig.extension'); $service->setPublic(false); $container->setDefinition('emanuele.minotto.faker.twig.extension', $service); }
private function processAdapterConfiguration(array $configuration, ContainerBuilder $container) { $definition = new Definition($configuration['class']); $definition->addArgument($configuration['options']); $definition->setPublic(false); $container->setDefinition('search.adapter', $definition); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $pool = $container->getDefinition('sonata.product.pool'); $calls = $pool->getMethodCalls(); $pool->setMethodCalls(array()); $map = array(); foreach ($calls as $method => $arguments) { if ($arguments[0] !== '__hack') { $pool->addMethodCall($arguments[0], $arguments[1]); continue; } foreach ($arguments[1] as $code => $options) { // define a new ProductDefinition $definition = new Definition('Sonata\\Component\\Product\\ProductDefinition', array(new Reference($options['provider']), new Reference($options['manager']))); $definition->setPublic(false); $container->setDefinition($code, $definition); $container->getDefinition($options['provider'])->addMethodCall('setCode', array($code)); $pool->addMethodCall('addProduct', array($code, new Reference($code))); $map[$code] = $container->getDefinition($options['manager'])->getArgument(0); $container->getDefinition($options['provider'])->addMethodCall('setBasketElementManager', array(new Reference('sonata.basket_element.manager'))); $container->getDefinition($options['provider'])->addMethodCall('setCurrencyPriceCalculator', array(new Reference('sonata.price.currency.calculator'))); $container->getDefinition($options['provider'])->addMethodCall('setProductCategoryManager', array(new Reference('sonata.product_category.product'))); $container->getDefinition($options['provider'])->addMethodCall('setProductCollectionManager', array(new Reference('sonata.product_collection.product'))); $container->getDefinition($options['provider'])->addMethodCall('setOrderElementClassName', array($container->getParameter('sonata.order.order_element.class'))); $container->getDefinition($options['provider'])->addMethodCall('setEventDispatcher', array(new Reference('event_dispatcher'))); if (array_key_exists('variations', $options)) { $container->getDefinition($options['provider'])->addMethodCall('setVariationFields', array($options['variations']['fields'])); } } } $container->getDefinition('sonata.product.subscriber.orm')->replaceArgument(0, $map); }
/** * 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 process(ContainerBuilder $container) { foreach ($container->findTaggedServiceIds('snc_redis.connection_parameters') as $id => $attr) { $clientAlias = $attr[0]['clientAlias']; $parameterDefinition = $container->getDefinition($id); $parameters = $parameterDefinition->getArgument(0); if ($parameters['logging']) { $optionId = sprintf('snc_redis.client.%s_options', $clientAlias); $option = $container->getDefinition($optionId); if (1 < count($option->getArguments())) { throw new \RuntimeException('Please check the predis option arguments.'); } $arguments = $option->getArgument(0); $connectionFactoryId = sprintf('snc_redis.%s_connectionfactory', $clientAlias); $connectionFactoryDef = new Definition($container->getParameter('snc_redis.connection_factory.class')); $connectionFactoryDef->setPublic(false); $connectionFactoryDef->addArgument(new Reference(sprintf('snc_redis.client.%s_profile', $clientAlias))); $connectionFactoryDef->addMethodCall('setConnectionWrapperClass', array($container->getParameter('snc_redis.connection_wrapper.class'))); $connectionFactoryDef->addMethodCall('setLogger', array(new Reference('snc_redis.logger'))); $container->setDefinition($connectionFactoryId, $connectionFactoryDef); $arguments['connections'] = new Reference($connectionFactoryId); $option->replaceArgument(0, $arguments); } } }
/** * 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'])); } }
/** * Loads the workflow configuration. * * @param array $workflows A workflow configuration array * @param ContainerBuilder $container A ContainerBuilder instance * @param XmlFileLoader $loader An XmlFileLoader instance */ private function registerWorkflowConfiguration(array $workflows, ContainerBuilder $container, XmlFileLoader $loader) { if (!$workflows) { return; } $loader->load('workflow.xml'); $registryDefinition = $container->getDefinition('workflow.registry'); foreach ($workflows as $name => $workflow) { $type = $workflow['type']; $transitions = array(); foreach ($workflow['transitions'] as $transitionName => $transition) { if ($type === 'workflow') { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $transition['from'], $transition['to'])); } elseif ($type === 'state_machine') { foreach ($transition['from'] as $from) { foreach ($transition['to'] as $to) { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $from, $to)); } } } } // Create a Definition $definitionDefinition = new Definition(Workflow\Definition::class); $definitionDefinition->setPublic(false); $definitionDefinition->addArgument($workflow['places']); $definitionDefinition->addArgument($transitions); $definitionDefinition->addTag('workflow.definition', array('name' => $name, 'type' => $type, 'marking_store' => isset($workflow['marking_store']['type']) ? $workflow['marking_store']['type'] : null)); if (isset($workflow['initial_place'])) { $definitionDefinition->addArgument($workflow['initial_place']); } // Create MarkingStore if (isset($workflow['marking_store']['type'])) { $parentDefinitionId = 'workflow.marking_store.' . $workflow['marking_store']['type']; $markingStoreDefinition = new DefinitionDecorator($parentDefinitionId); foreach ($workflow['marking_store']['arguments'] as $argument) { $markingStoreDefinition->addArgument($argument); } // explicitly set parent class to decorated definition in order to fix inconsistent behavior for <=2.7 // see https://github.com/symfony/symfony/issues/17353 and https://github.com/symfony/symfony/pull/15096 $markingStoreDefinition->setClass($container->getDefinition($parentDefinitionId)->getClass()); } elseif (isset($workflow['marking_store']['service'])) { $markingStoreDefinition = new Reference($workflow['marking_store']['service']); } // Create Workflow $workflowDefinition = new DefinitionDecorator(sprintf('%s.abstract', $type)); $workflowDefinition->replaceArgument(0, $definitionDefinition); if (isset($markingStoreDefinition)) { $workflowDefinition->replaceArgument(1, $markingStoreDefinition); } $workflowDefinition->replaceArgument(3, $name); // Store to container $workflowId = sprintf('%s.%s', $type, $name); $container->setDefinition($workflowId, $workflowDefinition); $container->setDefinition(sprintf('%s.definition', $workflowId), $definitionDefinition); // Add workflow to Registry foreach ($workflow['supports'] as $supportedClass) { $registryDefinition->addMethodCall('add', array(new Reference($workflowId), $supportedClass)); } } }
/** * @param string $name * @param array $config * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * * @return \Symfony\Component\DependencyInjection\Reference */ private function getConnectionReference($name, array $config, ContainerBuilder $container) { if (isset($config['client_id'])) { return new Reference($config['client_id']); } $parameters = array('scheme' => $config['scheme'], 'host' => $config['host'], 'port' => $config['port']); if ($config['password']) { $parameters['password'] = $config['password']; } if ($config['timeout']) { $parameters['timeout'] = $config['timeout']; } if ($config['database']) { $parameters['database'] = $config['database']; } $options = null; if (isset($config['options'])) { $options = $config['options']; } $clientClass = '%doctrine_cache.predis.client.class%'; $clientId = sprintf('doctrine_cache.services.%s_predis.client', $name); $clientDef = new Definition($clientClass); $clientDef->addArgument($parameters); $clientDef->addArgument($options); $clientDef->setPublic(false); $container->setDefinition($clientId, $clientDef); return new Reference($clientId); }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.xml'); $config = $this->getConfiguration($configs, $container); $config = $this->processConfiguration($config, $configs); foreach ($config['services'] as $name => $settings) { // until we can use file attachments in Guzzle in php 5.5 we block use of the upload type if ('upload' === $settings['type']) { throw new \ConfigurationException('The "upload" type is currently disabled due to PHP 5.5 cURL issues.'); } $def = new Definition($container->getParameter('pompdelux.kraken.service.class')); $def->setPublic(true); $def->setScope(ContainerInterface::SCOPE_CONTAINER); $def->addArgument(new Reference('pompdelux.kraken.guzzle.' . $settings['type'] . '.service')); $def->addArgument(new Reference('logger')); $def->addArgument(new Reference('router')); $def->addArgument($settings['api_key']); $def->addArgument($settings['api_secret']); $def->addArgument($settings['type']); $def->addArgument($settings['use_lossy']); $callback = $settings['callback'] ? $settings['callback_route'] : null; $def->addArgument($callback); $container->setDefinition(sprintf('pompdelux.kraken.%s', $name), $def); } }
public function testPoolRefsAreWeak() { $container = new ContainerBuilder(); $container->setParameter('kernel.debug', false); $container->setParameter('kernel.name', 'app'); $container->setParameter('kernel.environment', 'prod'); $container->setParameter('kernel.root_dir', 'foo'); $globalClearer = new Definition(Psr6CacheClearer::class); $container->setDefinition('cache.global_clearer', $globalClearer); $publicPool = new Definition(); $publicPool->addArgument('namespace'); $publicPool->addTag('cache.pool', array('clearer' => 'clearer_alias')); $container->setDefinition('public.pool', $publicPool); $privatePool = new Definition(); $privatePool->setPublic(false); $privatePool->addArgument('namespace'); $privatePool->addTag('cache.pool', array('clearer' => 'clearer_alias')); $container->setDefinition('private.pool', $privatePool); $clearer = new Definition(); $container->setDefinition('clearer', $clearer); $container->setAlias('clearer_alias', 'clearer'); $pass = new RemoveUnusedDefinitionsPass(); $pass->setRepeatedPass(new RepeatedPass(array($pass))); foreach (array(new CachePoolPass(), $pass, new CachePoolClearerPass()) as $pass) { $pass->process($container); } $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $clearer->getArguments()); $this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $globalClearer->getArguments()); }
/** * creates and registeres a classmap service definition * * @param ContainerBuilder $container * @param array $config * @return Definition * @author Daniel Wendlandt */ private function createClassMapDefinition(ContainerBuilder $container, array $config) { $classMapDef = new Definition(); $classMapDef->setPublic(false); $classMapDef->setClass($container->getParameter('elastification_php_client.repository.classmap.class')); $classMapDef->setArguments(array($config['elasticsearch_version'])); $container->setDefinition(ElastificationPhpClientExtension::SERVICE_REPOSITORY_CLASSMAP, $classMapDef); return $classMapDef; }
/** * {@inheritdoc} */ public function createService($name, array $config, ContainerBuilder $container) { $service_id = sprintf('jose.verifier.%s', $name); $definition = new Definition('Jose\\Verifier'); $definition->setFactory([new Reference('jose.factory.service'), 'createVerifier']); $definition->setArguments([$config['algorithms']]); $definition->setPublic($config['is_public']); $container->setDefinition($service_id, $definition); }
/** * You can modify the container here before it is dumped to PHP code. * * @param ContainerBuilder $container * * @api */ public function process(ContainerBuilder $container) { $requestManagerDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_REQUESTMANAGER_KEY); $transportDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_TRANSPORT_KEY); $clientDef = new Definition($container->getParameter('elastification_php_client.client.class'), array($transportDef, $requestManagerDef)); $clientDef->setPublic(false); $container->setDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_KEY, $clientDef); $container->setAlias(ElastificationPhpClientExtension::ALIAS_CLIENT, ElastificationPhpClientExtension::SERVICE_CLIENT_KEY); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('jms_translation.extractor.file_extractor')) { return; } $extractor = new Definition('APY\\DataGridBundle\\Translation\\ColumnTitleAnnotationTranslationExtractor'); $extractor->setPublic(false)->addTag('jms_translation.file_visitor'); $container->setDefinition('grid.translation_extractor', $extractor); }
private function createWizards(ContainerBuilder $container, array $wizards) { foreach ($wizards as $wizardName => $properties) { $wizardConfigurationDefinition = new Definition(WizardConfiguration::class, [$properties['steps'], new Reference('form.factory')]); $wizardConfigurationDefinition->setPublic(false); $wizardDefinition = new Definition(Wizard::class, [$wizardName, $wizardConfigurationDefinition, new Reference('event_dispatcher'), new Reference(str_replace('@', '', $properties['entity_manager']))]); $container->setDefinition('cms.form_wizard.' . $wizardName, $wizardDefinition); } }
/** * Configures the profiler data collector. * * @param ContainerBuilder $container Container * @param array $config Configuration */ public function configureProfiler(ContainerBuilder $container, array $config) { // Setup the data collector service for Symfony profiler $dataCollectorDef = new Definition(PheanstalkDataCollector::class); $dataCollectorDef->setPublic(false); $dataCollectorDef->addTag('data_collector', ['id' => 'pheanstalk', 'template' => $config['profiler']['template']]); $dataCollectorDef->addArgument(new Reference('leezy.pheanstalk.pheanstalk_locator')); $container->setDefinition('leezy.pheanstalk.data_collector', $dataCollectorDef); }
/** * {@inheritdoc} */ public function createService($name, array $config, ContainerBuilder $container) { $service_id = sprintf('jose.jwt_creator.%s', $name); $definition = new Definition('Jose\\JWTCreator'); $definition->setFactory([new Reference('jose.factory.service'), 'createJWTCreator']); $definition->setArguments([new Reference($config['signer']), null === $config['encrypter'] ? null : new Reference($config['encrypter'])]); $definition->setPublic($config['is_public']); $container->setDefinition($service_id, $definition); }
/** * {@inheritdoc} */ public function createService($name, array $config, ContainerBuilder $container) { $service_id = sprintf('jose.decrypter.%s', $name); $definition = new Definition('Jose\\Decrypter'); $definition->setFactory([new Reference('jose.factory.service'), 'createDecrypter']); $definition->setArguments([$config['key_encryption_algorithms'], $config['content_encryption_algorithms'], $config['compression_methods']]); $definition->setPublic($config['is_public']); $container->setDefinition($service_id, $definition); }
/** * Set the configuration for a section. * * @param string $name Name of the section, must be unique within the service-prefix * @param array $config Configuration of the section, must contain a 'prefix' key * * @return SectioningFactory Fluent interface */ public function set(string $name, array $config) : SectioningFactory { $sectionDef = new Definition(SectionConfiguration::class); $sectionDef->setPublic(false); $sectionDef->addArgument($config); $sectionDef->addTag(self::TAG_NAME, ['service_prefix' => $this->servicePrefix, 'section_name' => $name]); $this->container->setDefinition(sprintf('rollerworks.app_section.%s.%s', $this->servicePrefix, $name), $sectionDef); return $this; }
/** * Loads the Monolog configuration. * * @param array $config A configuration array * @param ContainerBuilder $container A ContainerBuilder instance */ protected function loadMonologHandler(array $config, ContainerBuilder $container) { $def2 = new Definition($config['monolog']['formatter']['class'], array($config['monolog']['formatter']['format'], $config['monolog']['formatter']['context_logging'], $config['monolog']['formatter']['extra_logging'], $config['monolog']['formatter']['words'])); $container->setDefinition('monolog.formatter.statsd', $def2); $def = new Definition($container->getParameter('liuggio_stats_d_client.monolog_handler.class'), array(new Reference('liuggio_stats_d_client.service'), new Reference('liuggio_stats_d_client.factory'), $config['monolog']['prefix'], $this->convertLevelToConstant($config['monolog']['level']))); $def->setPublic(false); $def->addMethodCall('setFormatter', array(new Reference('monolog.formatter.statsd'))); $container->setDefinition('monolog.handler.statsd', $def); }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $config = $this->processConfiguration(new Configuration(), $configs); $factoryDefinition = new Definition('Rabus\\Bundle\\Twitter\\SignInBundle\\Service\\ConnectionFactory', array($config['consumer_key'], $config['consumer_secret'])); $factoryDefinition->setPublic(false)->addMethodCall('setLogger', array(new Reference('logger', ContainerInterface::NULL_ON_INVALID_REFERENCE))); $container->setDefinition('rabus.twitter.connection_factory', $factoryDefinition); $loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); }