multi client configuration

Author: ASKozienko

GenericStatsStorageFactory.php

@@ -8,18 +8,62 @@
 
 class GenericStatsStorageFactory implements StatsStorageFactory
 {
-    public function create(string $dsn): StatsStorage
+    public function create($config): StatsStorage
     {
-        $schema = (new Dsn($dsn))->getScheme();
-
-        switch ($schema) {
-            case 'influxdb':
-                return new InfluxDbStorage($dsn);
-            case 'wamp':
-            case 'ws':
-                return new WampStorage($dsn);
-            default:
-                throw new \LogicException(sprintf('Unsupported stats storage: "%s"', $dsn));
+        if (is_string($config)) {
+            $config = ['dsn' => $config];
         }
+
+        if (false == is_array($config)) {
+            throw new \InvalidArgumentException('The config must be either array or DSN string.');
+        }
+
+        if (false == array_key_exists('dsn', $config)) {
+            throw new \InvalidArgumentException('The config must have dsn key set.');
+        }
+
+        $dsn = new Dsn($config['dsn']);
+
+        if ($storageClass = $this->findStorageClass($dsn, Resources::getKnownStorages())) {
+            return new $storageClass(1 === count($config) ? $config['dsn'] : $config);
+        }
+
+        throw new \LogicException(sprintf(
+            'A given scheme "%s" is not supported.',
+            $dsn->getScheme(),
+            Resources::class
+        ));
+    }
+
+    private function findStorageClass(Dsn $dsn, array $factories): ?string
+    {
+        $protocol = $dsn->getSchemeProtocol();
+
+        if ($dsn->getSchemeExtensions()) {
+            foreach ($factories as $storageClass => $info) {
+                if (empty($info['supportedSchemeExtensions'])) {
+                    continue;
+                }
+
+                if (false == in_array($protocol, $info['schemes'], true)) {
+                    continue;
+                }
+
+                $diff = array_diff($info['supportedSchemeExtensions'], $dsn->getSchemeExtensions());
+                if (empty($diff)) {
+                    return $storageClass;
+                }
+            }
+        }
+
+        foreach ($factories as $storageClass => $info) {
+            if (false == in_array($protocol, $info['schemes'], true)) {
+                continue;
+            }
+
+            return $storageClass;
+        }
+
+        return null;
     }
 }

Resources.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Enqueue\Monitoring;
+
+
+final class Resources
+{
+    /**
+     * @var array
+     */
+    private static $knownStorages = null;
+
+    private function __construct()
+    {
+    }
+
+    public static function getKnownSchemes(): array
+    {
+        $map = self::getKnownStorages();
+
+        $schemes = [];
+        foreach ($map as $storageClass => $item) {
+            foreach ($item['schemes'] as $scheme) {
+                $schemes[$scheme] = $storageClass;
+            }
+        }
+
+        return $schemes;
+    }
+
+    public static function getKnownStorages(): array
+    {
+        if (null === self::$knownStorages) {
+            $map = [];
+
+            $map[WampStorage::class] = [
+                'schemes' => ['wamp', 'ws'],
+                'supportedSchemeExtensions' => [],
+            ];
+
+            $map[InfluxDbStorage::class] = [
+                'schemes' => ['influxdb'],
+                'supportedSchemeExtensions' => [],
+            ];
+
+            self::$knownStorages = $map;
+        }
+
+        return self::$knownStorages;
+    }
+}

StatsStorageFactory.php

@@ -6,5 +6,5 @@
 
 interface StatsStorageFactory
 {
-    public function create(string $dsn): StatsStorage;
+    public function create($config): StatsStorage;
 }

Symfony/DependencyInjection/MonitoringFactory.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Enqueue\Monitoring\Symfony\DependencyInjection;
+
+use Enqueue\Monitoring\GenericStatsStorageFactory;
+use Enqueue\Monitoring\Resources;
+use Enqueue\Monitoring\StatsStorage;
+use Enqueue\Monitoring\StatsStorageFactory;
+use Enqueue\Symfony\DependencyInjection\FormatTransportNameTrait;
+use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * @internal
+ */
+final class MonitoringFactory
+{
+    use FormatTransportNameTrait;
+
+    /**
+     * @var string
+     */
+    private $name;
+
+    public function __construct(string $name)
+    {
+        if (empty($name)) {
+            throw new \InvalidArgumentException('The name could not be empty.');
+        }
+
+        $this->name = $name;
+    }
+
+    public function getConfiguration(string $name): ArrayNodeDefinition
+    {
+        $builder = new ArrayNodeDefinition($name);
+
+        $builder
+            ->info(sprintf('The "%s" option could accept a string DSN, an array with DSN key, or null. It accept extra options. To find out what option you can set, look at stats storage constructor doc block.', $name))
+            ->beforeNormalization()
+                ->always(function ($v) {
+                    if (is_array($v)) {
+                        if (isset($v['storage_factory_class']) && isset($v['storage_factory_service'])) {
+                            throw new \LogicException('Both options storage_factory_class and storage_factory_service are set. Please choose one.');
+                        }
+
+                        return $v;
+                    }
+
+                    if (is_string($v)) {
+                        return ['dsn' => $v];
+                    }
+
+                    return $v;
+                })
+        ->end()
+        ->ignoreExtraKeys(false)
+        ->children()
+            ->scalarNode('dsn')
+                ->cannotBeEmpty()
+                ->isRequired()
+                ->info(sprintf('The stats storage DSN. These schemes are supported: "%s".', implode('", "', array_keys(Resources::getKnownSchemes()))))
+            ->end()
+            ->scalarNode('storage_factory_service')
+                ->info(sprintf('The factory class should implement "%s" interface', StatsStorageFactory::class))
+            ->end()
+            ->scalarNode('storage_factory_class')
+                ->info(sprintf('The factory service should be a class that implements "%s" interface', StatsStorageFactory::class))
+            ->end()
+        ->end()
+        ;
+
+        return $builder;
+    }
+
+    public function getName(): string
+    {
+        return $this->name;
+    }
+
+    public function buildStorage(ContainerBuilder $container, array $config): void
+    {
+        $storageId = $this->format('storage');
+        $storageFactoryId = $this->format('storage.factory');
+
+        if (isset($config['storage_factory_service'])) {
+            $container->setAlias($storageFactoryId, $config['storage_factory_service']);
+        } elseif (isset($config['storage_factory_class'])) {
+            $container->register($storageFactoryId, $config['storage_factory_class']);
+        } else {
+            $container->register($storageFactoryId, GenericStatsStorageFactory::class);
+        }
+
+        unset($config['storage_factory_service'], $config['storage_factory_class']);
+
+        $container->register($storageId, StatsStorage::class)
+            ->setFactory([new Reference($storageFactoryId), 'create'])
+            ->addArgument($config)
+        ;
+    }
+}

Tests/GenericStatsStorageFactoryTest.php

@@ -35,7 +35,7 @@ public function testShouldCreateWampStorage()
     public function testShouldThrowIfStorageIsNotSupported()
     {
         $this->expectException(\LogicException::class);
-        $this->expectExceptionMessage('Unsupported stats storage: "unsupported:"');
+        $this->expectExceptionMessage('A given scheme "unsupported" is not supported.');
 
         (new GenericStatsStorageFactory())->create('unsupported:');
     }