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;
}
