Sets a factory.
public setFactory ( string | array $factory ) : |
||
$factory | string | array | A PHP function or an array containing a class/Reference and a method to call |
Résultat | The current instance |
/** * {@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); } } }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\StorableJWK'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createStorableKey']); $definition->setArguments([$config['storage_path'], $this->getKeyConfig($config)]); return $definition; }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\JWK'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromKeyFile']); $definition->setArguments([$config['path'], $config['password'], $config['additional_values']]); return $definition; }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\X5UJWKSet'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromX5U']); $definition->setArguments([$config['url'], $config['is_secured'], $config['cache'], $config['cache_ttl'], $config['is_https']]); return $definition; }
private function buildRevalidationDefinition(array $cacheConfiguration) { $factory = new Definition(RevalidationFactory::class); $revalidation = new Definition(RevalidationInterface::class, [$cacheConfiguration['validation']]); $revalidation->setFactory([$factory, 'create']); return $revalidation; }
private function convertFactoryDefinition(ContainerBuilder $container, $definition) { $symfonyDefinition = new Definition('Class'); $symfonyDefinition->setFactory([$this->convertArguments($container, $definition->getFactory()), $definition->getMethodName()]); $symfonyDefinition->setArguments($this->convertArguments($container, $definition->getArguments())); return $symfonyDefinition; }
protected function registerRepository($name, $repositoryClass, $entityClass, ContainerBuilder $container) { $definition = new Definition($repositoryClass); $definition->setFactory([new Reference('doctrine.orm.entity_manager'), 'getRepository']); $definition->addArgument($entityClass); $container->setDefinition($name . '.repository', $definition); }
private function createServiceDefinition($name) { $clientClass = "Aws\\{$name}\\{$name}Client"; $serviceDefinition = new Definition(class_exists($clientClass) ? $clientClass : AwsClient::class); $serviceDefinition->setFactory([new Reference('aws_sdk'), 'create' . $name]); return $serviceDefinition; }
/** * 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); }
/** * {@inheritDoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $immutableProperties = array_merge($config['content_immutable_properties'], array('linkedToSite', 'deleted')); $container->setParameter('open_orchestra_model.content.immutable_properties', $immutableProperties); foreach ($config['fixtures_interface'] as $command => $content) { $container->setParameter('open_orchestra_model.fixtures_interface.' . $command, $content); } $container->setParameter('open_orchestra_model.fixtures.command', array_keys($config['fixtures_interface'])); foreach ($config['document'] as $class => $content) { if (is_array($content)) { $container->setParameter('open_orchestra_model.document.' . $class . '.class', $content['class']); if (array_key_exists('repository', $content)) { $definition = new Definition($content['repository'], array($content['class'])); $definition->setFactory(array(new Reference('doctrine.odm.mongodb.document_manager'), 'getRepository')); $definition->addMethodCall('setAggregationQueryBuilder', array(new Reference('doctrine_mongodb.odm.default_aggregation_query'))); if (method_exists($content['repository'], 'setFilterTypeManager')) { $definition->addMethodCall('setFilterTypeManager', array(new Reference('open_orchestra_pagination.filter_type.manager'))); } $container->setDefinition('open_orchestra_model.repository.' . $class, $definition); } } } $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('listener.yml'); $loader->load('validator.yml'); $loader->load('manager.yml'); $loader->load('saver.yml'); $loader->load('form.yml'); $loader->load('transformer.yml'); $loader->load('helper.yml'); }
/** * @param array $configs * @param ContainerBuilder $container */ public function load(array $configs, ContainerBuilder $container) { $this->container = $container; $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $connectionsConfig = $config['connections']; $exchangesConfig = $config['exchanges']; $container->setParameter('hector.config.connections', $connectionsConfig); $container->setParameter('hector.config.exchanges', $exchangesConfig); $contextRegistry = $container->getDefinition('hector.context.registry'); foreach ($exchangesConfig as $exchangeName => $exchangeConfiguration) { $exchangeContextServiceName = 'hector.exchange.context.' . $exchangeName; $exchangeContext = new Definition(ExchangeContext::class, [$exchangeConfiguration]); $exchangeContext->setFactory('Evaneos\\Hector\\Exchange\\Context::createFromConfig'); $container->setDefinition($exchangeContextServiceName, $exchangeContext); $contextRegistry->addMethodCall('addExchangeContext', [$exchangeName, new Reference($exchangeContextServiceName)]); if (!isset($exchangeConfiguration['queues'])) { continue; } foreach ($exchangeConfiguration['queues'] as $queueName => $queueConfiguration) { $queueContextServiceName = 'hector.queue.context.' . $queueName; $queueContext = new Definition(QueueContext::class, [$queueConfiguration]); $queueContext->setFactory('Evaneos\\Hector\\Queue\\Context::createFromConfig'); $container->setDefinition($queueContextServiceName, $queueContext); $contextRegistry->addMethodCall('addQueueContext', [$queueName, new Reference($queueContextServiceName)]); } } // Register Connections foreach ($config['connections'] as $name => $connectionConfig) { $this->registerConnection($name, $connectionConfig); } }
/** * @inheritDoc */ public function createServiceDefinitions(array $data, ContainerBuilder $container, $prefix) { if (!isset($data['host'])) { throw new UrlResolveException("No region hostname found in url"); } if (!isset($data['user'])) { throw new UrlResolveException("No key (username) found in url"); } if (!isset($data['pass'])) { throw new UrlResolveException("No secret (password) found in url"); } if (!isset($data['clean_path'])) { throw new UrlResolveException("No bucket name (path) found in url"); } $region = $data['host']; $key = $data['user']; $secret = $data['pass']; $bucket = $data['clean_path']; $adapterPrefix = null; if (isset($data['prefix'])) { $adapterPrefix = $data['prefix']; } $version = 'latest'; if (isset($data['version'])) { $version = $data['version']; } $client = new Definition('Aws\\S3\\S3Client'); $client->setFactory(['Aws\\S3\\S3Client', 'factory']); $client->setArguments([['credentials' => ['key' => $key, 'secret' => $secret], 'region' => $region, 'version' => $version]]); $container->setDefinition("{$prefix}.client", $client); $container->setDefinition("{$prefix}.adapter", new Definition('League\\Flysystem\\AwsS3v3\\AwsS3Adapter', [new Reference("{$prefix}.client"), $bucket, $adapterPrefix])); return "{$prefix}.adapter"; }
/** * {@inheritDoc} */ public function load(ContainerBuilder $container) { $omnipayFactory = new Definition(GatewayFactory::class); $omnipayFactory->setFactory([Omnipay::class, 'getFactory']); $container->setDefinition('payum.omnipay_factory', $omnipayFactory); parent::load($container); }
public function create(string $class) : Definition { $definition = new Definition(EntityManager::class); $definition->setFactory([new Reference('doctrine.orm.entity_manager'), 'getRepository']); $definition->addArgument($class); return $definition; }
/** * @param string $service * @param string $alias * * @return Definition */ private function createMenuService($service, $alias) { $definition = new Definition(ItemInterface::class); $definition->setFactory([new Reference($service), 'create']); $definition->addTag('knp_menu.menu', ['alias' => $alias]); return $definition; }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\JWK'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromCertificate']); $definition->setArguments([$config['value']]); return $definition; }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\JWKSet'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromValues']); $definition->setArguments([json_decode($config['value'], true)]); return $definition; }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $connections = $container->getParameter('es.connections'); $managers = $container->getParameter('es.managers'); foreach ($managers as $managerName => $settings) { $bundlesMetadata = $this->getBundlesMetadata($container, $settings); $classMetadataCollection = new Definition('ONGR\\ElasticsearchBundle\\Mapping\\ClassMetadataCollection', [$bundlesMetadata]); $managerDefinition = new Definition('ONGR\\ElasticsearchBundle\\ORM\\Manager', [$this->getConnectionDefinition($container, $connections, $settings), $classMetadataCollection]); $managerName = strtolower($managerName); $container->setDefinition(sprintf('es.manager.%s', $managerName), $managerDefinition); if ($managerName === 'default') { $container->setAlias('es.manager', 'es.manager.default'); } /** @var Definition $data */ foreach ($bundlesMetadata as $repository => $data) { $repositoryDefinition = new Definition('ONGR\\ElasticsearchBundle\\ORM\\Repository', [$repository]); $repositoryDefinition->setFactory([new Reference(sprintf('es.manager.%s', $managerName)), 'getRepository']); $repository = substr($repository, strpos($repository, ':') + 1); $repositoryId = sprintf('es.manager.%s.%s', $managerName, $repository); if (strtolower(substr($repository, -8)) === 'document') { $container->setAlias(sprintf('es.manager.%s.%s', $managerName, substr($repository, 0, strlen($repository) - 8)), $repositoryId); } $container->setDefinition($repositoryId, $repositoryDefinition); } } }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\JWK'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromKeySet']); $definition->setArguments([new Reference($config['key_set']), $config['index']]); return $definition; }
public function it_should_process(ContainerBuilder $c, Definition $definition) { $c->findTaggedServiceIds('hector.publisher')->shouldBeCalled()->willReturn(['publisher' => [['routing_key_prefix' => 'foo', 'exchange' => 'bar']]]); $definition->setFactory([new Reference('hector.publisher.factory'), 'create'])->shouldBeCalled(); $definition->setArguments(['default', 'bar', null, ['routing_key_prefix' => 'foo']])->shouldBeCalled(); $c->getDefinition('publisher')->shouldBeCalled()->willReturn($definition); $this->process($c); }
/** * @param string $instanceName * @param array $mergedConfig * @param ContainerBuilder $container */ protected function buildEntityRepositories($instanceName, array $mergedConfig, ContainerBuilder $container) { foreach ($mergedConfig['repositories'] as $name => $repositoryKey) { $definition = new Definition('PhraseanetSDK\\Repository\\AbstractRepository', array($repositoryKey)); $definition->setFactory([new Reference('phraseanet.factories.' . $instanceName), 'getRepository']); $container->setDefinition($name, $definition); } }
private function buildServiceProxyFactoryDefinition($taggedServiceName, $tagParameters) { $definition = $this->container->findDefinition($taggedServiceName); $factoryDefinition = new Definition(); $factoryDefinition->setFactory([new Reference('openclassrooms.service_proxy.service_proxy_factory'), 'create']); $factoryDefinition->setArguments([$definition, $tagParameters[0]]); $this->container->setDefinition($taggedServiceName, $factoryDefinition); }
/** * {@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); }
/** * @param ContainerBuilder $container * @param MetadataInterface $metadata */ protected function addController(ContainerBuilder $container, MetadataInterface $metadata) { // @todo: Remove when ResourceController is reworked. $configurationDefinition = new Definition(new Parameter('sylius.controller.configuration.class')); $configurationDefinition->setFactory(array(new Reference('sylius.controller.configuration_factory'), 'createConfiguration'))->setArguments(array($metadata->getApplicationName(), $metadata->getName(), $metadata->getTemplatesNamespace()))->setPublic(false); $definition = new Definition($metadata->getClass('controller')); $definition->setArguments(array($configurationDefinition))->addMethodCall('setContainer', array(new Reference('service_container'))); $container->setDefinition($metadata->getServiceId('controller'), $definition); }
/** * @param array $connections */ private function defineConnections(array $connections) { foreach ($connections as $name => $conf) { $connectionDefinition = new Definition(Database::class, [$conf['client_name'], $conf['database_name']]); $connectionDefinition->setFactory([new Reference('mongo.connection_factory'), 'createConnection']); $this->containerBuilder->setDefinition('mongo.connection.' . $name, $connectionDefinition); } $this->containerBuilder->setAlias('mongo.connection', 'mongo.connection.' . array_keys($connections)[0]); }
/** * {@inheritdoc} * * Rewrites previous service definitions in order to force the dumped container to use * dynamic configuration parameters. Technique may vary depending on the target service * (see for example https://github.com/opensky/OpenSkyRuntimeConfigBundle). * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { //pdf $pdf = new Definition(); $pdf->setFactory(array(new Reference('claroline.pdf_generator_factory'), 'getPdfCreator')); $pdf->setClass('Knp\\Snappy\\Pdf'); $container->removeDefinition('knp_snappy.pdf.internal_generator'); $container->setDefinition('knp_snappy.pdf.internal_generator', $pdf); }
/** * {@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); }
/** * {@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.checker.%s', $name); $definition = new Definition('Jose\\Checker\\CheckerManager'); $definition->setFactory([new Reference('jose.factory.service'), 'createChecker']); $definition->setArguments([$config['claims'], $config['headers']]); $definition->setPublic($config['is_public']); $container->setDefinition($service_id, $definition); }
/** * {@inheritdoc} */ public function createDefinition(ContainerBuilder $container, array $config) { $definition = new Definition('Jose\\Object\\JWKSet'); $definition->setFactory([new Reference('jose.factory.jwk'), 'createKeySets']); foreach ($config['id'] as $key_set_id) { $ref = new Reference($key_set_id); $definition->addMethodCall('addKeySet', [$ref]); } return $definition; }