├── .gitignore
├── Auth
    ├── AuthInterface.php
    └── TokenAuth.php
├── Client
    ├── BaseUriConfiguratorInterface.php
    ├── VaultReaderClientInterface.php
    ├── VaultWriterClientInterface.php
    ├── BaseUriConfigurator.php
    └── VaultClient.php
├── ParameterGetter
    ├── ParameterGetterInterface.php
    └── ParameterGetter.php
├── ParameterProvider
    ├── ParameterProviderInterface.php
    ├── SimpleParameterProvider.php
    ├── VaultParameterProviderFactory.php
    └── VaultParameterProvider.php
├── ParameterMapper
    ├── SimpleParameterMapper.php
    ├── ParameterMapperInterface.php
    └── YamlParameterMapper.php
├── Tests
    ├── Functional
    │   ├── Resources
    │   │   └── config
    │   │   │   ├── config_vault_parameter_test.yml
    │   │   │   └── config.yml
    │   ├── VaultWebTestCase.php
    │   ├── VaultParameterProviderTest.php
    │   └── Kernel.php
    └── Unit
    │   └── ParameterMapper
    │       └── YamlParameterMapperTest.php
├── .travis.yml
├── composer.json
├── DependencyInjection
    ├── Compiler
    │   ├── CachedParameterCompilerPass.php
    │   └── DynamicParameterCompilerPass.php
    ├── Configuration.php
    └── FourxxiVaultExtension.php
├── FourxxiVaultBundle.php
├── Resources
    └── config
    │   └── services.yml
├── ExpressionLanguage
    └── VaultParameterExpressionLanguageProvider.php
├── phpunit.xml.dist
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | vendor/
3 | composer.lock
4 | phpunit.xml
5 | Tests/Functional/var
6 | Resources/docs
7 | .php_cs.dist
8 | 


--------------------------------------------------------------------------------
/Auth/AuthInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Auth;
 4 | 
 5 | interface AuthInterface
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public function getToken(): string;
11 | }
12 | 


--------------------------------------------------------------------------------
/Client/BaseUriConfiguratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Client;
 4 | 
 5 | interface BaseUriConfiguratorInterface
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public function getUri(): string;
11 | }
12 | 


--------------------------------------------------------------------------------
/Client/VaultReaderClientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Client;
 4 | 
 5 | interface VaultReaderClientInterface
 6 | {
 7 |     /**
 8 |      * @param string $pathProvider
 9 |      *
10 |      * @return array
11 |      */
12 |     public function read(string $path);
13 | }
14 | 


--------------------------------------------------------------------------------
/Client/VaultWriterClientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Client;
 4 | 
 5 | interface VaultWriterClientInterface
 6 | {
 7 |     /**
 8 |      * @param string $path
 9 |      * @param array  $value
10 |      *
11 |      * @return mixed
12 |      */
13 |     public function write(string $path, array $value);
14 | }
15 | 


--------------------------------------------------------------------------------
/ParameterGetter/ParameterGetterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterGetter;
 4 | 
 5 | interface ParameterGetterInterface
 6 | {
 7 |     /**
 8 |      * @param $providerName
 9 |      * @param $field
10 |      *
11 |      * @return mixed
12 |      */
13 |     public function get(string $providerName, string $fieldName);
14 | }
15 | 


--------------------------------------------------------------------------------
/ParameterProvider/ParameterProviderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterProvider;
 4 | 
 5 | interface ParameterProviderInterface
 6 | {
 7 |     /**
 8 |      * @param $path
 9 |      *
10 |      * @return mixed
11 |      */
12 |     public function get($field);
13 | 
14 |     /**
15 |      * @return array
16 |      */
17 |     public function all();
18 | }
19 | 


--------------------------------------------------------------------------------
/ParameterMapper/SimpleParameterMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterMapper;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 6 | 
 7 | class SimpleParameterMapper implements ParameterMapperInterface
 8 | {
 9 |     /**
10 |      * {@inheritdoc}
11 |      */
12 |     public function map(array $response): ParameterBag
13 |     {
14 |         return new ParameterBag($response['data']);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Tests/Functional/Resources/config/config_vault_parameter_test.yml:
--------------------------------------------------------------------------------
 1 | imports:
 2 |     - { resource: config.yml }
 3 | 
 4 | services:
 5 |     fourxxi_vault.test.mapper.yaml:
 6 |             class: Fourxxi\Bundle\VaultBundle\ParameterMapper\YamlParameterMapper
 7 |             arguments: ["value"]
 8 |             public: true
 9 | 
10 |     fourxxi_vault.test.mapper.simple:
11 |         class: Fourxxi\Bundle\VaultBundle\ParameterMapper\SimpleParameterMapper
12 |         public: true


--------------------------------------------------------------------------------
/ParameterMapper/ParameterMapperInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterMapper;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 6 | 
 7 | interface ParameterMapperInterface
 8 | {
 9 |     /**
10 |      * Mapping data from vault to other objects.
11 |      *
12 |      * @param array $response
13 |      *
14 |      * @return ParameterBag
15 |      */
16 |     public function map(array $response): ParameterBag;
17 | }
18 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: required
 2 | 
 3 | language: php
 4 | 
 5 | services:
 6 |     - docker
 7 | 
 8 | php:
 9 |     - '7.1'
10 | 
11 | branches:
12 |     only:
13 |         - master
14 |         - develop
15 | 
16 | before_install:
17 |     - docker pull vault
18 | 
19 | before_script:
20 |     - composer install --no-interaction --dev
21 |     - docker run -d -p 8200:8200 --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=f29e2a2f-26ac-a182-b7a9-05be2381e200' vault
22 |     - sleep 2
23 |     - curl http://127.0.0.1:8200/v1/sys/health
24 | 
25 | script:
26 |     - phpunit


--------------------------------------------------------------------------------
/Auth/TokenAuth.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Auth;
 4 | 
 5 | class TokenAuth implements AuthInterface
 6 | {
 7 |     /**
 8 |      * @var string
 9 |      */
10 |     private $token;
11 | 
12 |     /**
13 |      * TokenAuth constructor.
14 |      *
15 |      * @param string $token
16 |      */
17 |     public function __construct(string $token)
18 |     {
19 |         $this->token = $token;
20 |     }
21 | 
22 |     /**
23 |      * @return string
24 |      */
25 |     public function getToken(): string
26 |     {
27 |         return $this->token;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/Tests/Functional/Resources/config/config.yml:
--------------------------------------------------------------------------------
 1 | framework:
 2 |     secret: 'test'
 3 | 
 4 | fourxxi_vault:
 5 |     enabled: true
 6 |     auth:
 7 |         token: "%env(vault_token)%"
 8 |     connection:
 9 |         schema: "%env(vault_schema)%"
10 |         host: "%env(vault_host)%"
11 |         port: "%env(vault_port)%"
12 |         api_version: '%env(vault_api_version)%'
13 | 
14 | services:
15 |     fourxxi_vault.test.writer_client:
16 |         class: Fourxxi\Bundle\VaultBundle\Client\VaultClient
17 |         arguments: ["@fourxxi_vault.auth", "@fourxxi_vault.client.base_uri_configurator"]
18 |         public: true


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "fourxxi/vault-bundle",
 3 |   "description": "Symfony bundle for vault integration",
 4 |   "keywords": ["vault"],
 5 |   "type": "symfony-bundle",
 6 |   "license": "MIT",
 7 |   "require": {
 8 |     "php" : "^7.0",
 9 |     "symfony/framework-bundle": ">=2.8",
10 |     "symfony/options-resolver": ">=2.8",
11 |     "symfony/yaml": ">=2.8",
12 |     "symfony/expression-language": ">=2.8",
13 |     "guzzlehttp/guzzle": ">=6.0"
14 |   },
15 |   "autoload": {
16 |     "psr-4": { "Fourxxi\\Bundle\\VaultBundle\\": "" }
17 |   },
18 |   "require-dev": {
19 |     "phpunit/phpunit": "^6",
20 |     "symfony/phpunit-bridge": "^4",
21 |     "symfony/finder": ">=2.8"
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/Tests/Functional/VaultWebTestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Tests\Functional;
 4 | 
 5 | use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
 6 | 
 7 | class VaultWebTestCase extends WebTestCase
 8 | {
 9 |     protected function setUp()
10 |     {
11 |         $this->bootKernel(['environment' => $this->getEnvironment()]);
12 |     }
13 | 
14 |     protected static function getKernelClass()
15 |     {
16 |         // compatibility with symfony 2.8
17 |         if (isset($_ENV['KERNEL_CLASS'])) {
18 |             return $_ENV['KERNEL_CLASS'];
19 |         }
20 | 
21 |         return parent::getKernelClass();
22 |     }
23 | 
24 |     /**
25 |      * @return string
26 |      */
27 |     protected function getEnvironment(): string
28 |     {
29 |         return 'test';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/CachedParameterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\DependencyInjection\Compiler;
 4 | 
 5 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | 
 8 | class CachedParameterCompilerPass implements CompilerPassInterface
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public function process(ContainerBuilder $container)
14 |     {
15 |         if ($container->getParameter('fourxxi_vault.enabled') === false) {
16 |             return;
17 |         }
18 | 
19 |         $taggedServices = $container->findTaggedServiceIds('fourxxi_vault.cached_parameters');
20 |         foreach ($taggedServices as $id => $info) {
21 |             $container->getParameterBag()->add($container->get($id)->all());
22 |         }
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/FourxxiVaultBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\DependencyInjection\Compiler\CachedParameterCompilerPass;
 6 | use Fourxxi\Bundle\VaultBundle\DependencyInjection\Compiler\DynamicParameterCompilerPass;
 7 | use Fourxxi\Bundle\VaultBundle\ExpressionLanguage\VaultParameterExpressionLanguageProvider;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\HttpKernel\Bundle\Bundle;
10 | 
11 | class FourxxiVaultBundle extends Bundle
12 | {
13 |     public function build(ContainerBuilder $container)
14 |     {
15 |         $container->addExpressionLanguageProvider(
16 |             new VaultParameterExpressionLanguageProvider()
17 |         );
18 | 
19 |         $container->addCompilerPass(new CachedParameterCompilerPass());
20 |         $container->addCompilerPass(new DynamicParameterCompilerPass());
21 | 
22 |         parent::build($container);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Resources/config/services.yml:
--------------------------------------------------------------------------------
 1 | parameters:
 2 |     fourxxi_vault.enabled: false
 3 |     fourxxi_vault.client.base_uri_configurator.class: Fourxxi\Bundle\VaultBundle\Client\BaseUriConfigurator
 4 | 
 5 | services:
 6 |     fourxxi_vault.auth:
 7 |         class: Fourxxi\Bundle\VaultBundle\Auth\AuthInterface
 8 | 
 9 |     fourxxi_vault.client.base_uri_configurator:
10 |         class: "%fourxxi_vault.client.base_uri_configurator.class%"
11 | 
12 |     fourxxi_vault.client.client:
13 |         class: Fourxxi\Bundle\VaultBundle\Client\VaultClient
14 |         arguments: ["@fourxxi_vault.auth","@fourxxi_vault.client.base_uri_configurator"]
15 | 
16 |     fourxxi_vault.parameter_provider.vault_factory:
17 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\VaultParameterProviderFactory
18 |         arguments: ["@fourxxi_vault.client.client"]
19 |         public: true
20 | 
21 |     fourxxi_vault.parameter_getter:
22 |         class: Fourxxi\Bundle\VaultBundle\ParameterGetter\ParameterGetter
23 | 


--------------------------------------------------------------------------------
/ParameterProvider/SimpleParameterProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterProvider;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 6 | 
 7 | class SimpleParameterProvider implements ParameterProviderInterface
 8 | {
 9 |     /**
10 |      * @var ParameterBag
11 |      */
12 |     private $parameterBag;
13 | 
14 |     /**
15 |      * SimpleParameterProvider constructor.
16 |      *
17 |      * @param ParameterBag $parameterBag
18 |      */
19 |     public function __construct(ParameterBag $parameterBag)
20 |     {
21 |         $this->parameterBag = $parameterBag;
22 |         $this->parameterBag->resolve();
23 |     }
24 | 
25 |     /**
26 |      * {@inheritdoc}
27 |      */
28 |     public function get($name)
29 |     {
30 |         return $this->parameterBag->get($name);
31 |     }
32 | 
33 |     /**
34 |      * {@inheritdoc}
35 |      */
36 |     public function all()
37 |     {
38 |         return $this->parameterBag->all();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/Tests/Unit/ParameterMapper/YamlParameterMapperTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Tests\Unit\ParameterMapper;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\ParameterMapper\YamlParameterMapper;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | final class YamlParameterMapperTest extends TestCase
 9 | {
10 |     const EXPECTED_VALUE = 'expected_value';
11 | 
12 |     /**
13 |      * @test
14 |      */
15 |     public function parsesYamlFieldFromResponse(): void
16 |     {
17 |         $response = ['data' => [self::EXPECTED_VALUE => 'field: value']];
18 |         $mapper = new YamlParameterMapper(self::EXPECTED_VALUE);
19 | 
20 |         $this->assertEquals(['field' => 'value'], $mapper->map($response)->all());
21 |     }
22 | 
23 |     /**
24 |      * @test
25 |      */
26 |     public function throwsErrorIfFieldIsMissing()
27 |     {
28 |         $this->expectException(\LogicException::class);
29 | 
30 |         $mapper = new YamlParameterMapper('missing_value');
31 |         $mapper->map([]);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/ParameterGetter/ParameterGetter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterGetter;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\ParameterProvider\ParameterProviderInterface;
 6 | 
 7 | class ParameterGetter implements ParameterGetterInterface
 8 | {
 9 |     /**
10 |      * @var ParameterProviderInterface[]
11 |      */
12 |     private $providers;
13 | 
14 |     /**
15 |      * ParameterProviderCollection constructor.
16 |      *
17 |      * @param ParameterProviderInterface[] $providers
18 |      */
19 |     public function __construct(array $providers = [])
20 |     {
21 |         $this->providers = $providers;
22 |     }
23 | 
24 |     /**
25 |      * {@inheritdoc}
26 |      */
27 |     public function get(string $providerName, string $fieldName)
28 |     {
29 |         if (!isset($this->providers[$providerName])) {
30 |             throw new \LogicException("Provider with name $providerName doesn't exist");
31 |         }
32 | 
33 |         return $this->providers[$providerName]->get($fieldName);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/ParameterMapper/YamlParameterMapper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterMapper;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 6 | use Symfony\Component\Yaml\Yaml;
 7 | 
 8 | class YamlParameterMapper implements ParameterMapperInterface
 9 | {
10 |     /**
11 |      * @var string
12 |      */
13 |     protected $valueField;
14 | 
15 |     /**
16 |      * YamlParameterMapper constructor.
17 |      *
18 |      * @param string $valueField
19 |      */
20 |     public function __construct(string $valueField = 'value')
21 |     {
22 |         $this->valueField = $valueField;
23 |     }
24 | 
25 |     /**
26 |      * {@inheritdoc}
27 |      */
28 |     public function map(array $response): ParameterBag
29 |     {
30 |         if (!isset($response['data'][$this->valueField])) {
31 |             throw new \LogicException(sprintf(
32 |                 'Parameter %s does not exist in the data array',
33 |                 $this->valueField
34 |             ));
35 |         }
36 | 
37 |         return new ParameterBag(Yaml::parse($response['data'][$this->valueField]));
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Client/BaseUriConfigurator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Client;
 4 | 
 5 | class BaseUriConfigurator implements BaseUriConfiguratorInterface
 6 | {
 7 |     /**
 8 |      * @var
 9 |      */
10 |     protected $apiVersion;
11 | 
12 |     /**
13 |      * @var string
14 |      */
15 |     protected $schema;
16 | 
17 |     /**
18 |      * @var string
19 |      */
20 |     protected $host;
21 | 
22 |     /**
23 |      * @var string
24 |      */
25 |     protected $port;
26 | 
27 |     /**
28 |      * Configurator constructor.
29 |      *
30 |      * @param $config
31 |      */
32 |     public function __construct($config)
33 |     {
34 |         $this->schema = $config['connection']['schema'];
35 |         $this->host = $config['connection']['host'];
36 |         $this->port = $config['connection']['port'];
37 |         $this->apiVersion = $config['connection']['api_version'];
38 |     }
39 | 
40 |     /**
41 |      * @return string
42 |      */
43 |     public function getUri(): string
44 |     {
45 |         return sprintf('%s://%s:%s/%s/', $this->schema, $this->host, $this->port, $this->apiVersion);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/DynamicParameterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\DependencyInjection\Compiler;
 4 | 
 5 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | 
 8 | class DynamicParameterCompilerPass implements CompilerPassInterface
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public function process(ContainerBuilder $container)
14 |     {
15 |         $enabled = $container->getParameter('fourxxi_vault.enabled');
16 |         $tag = sprintf('fourxxi_vault.%s_parameter_provider', true === $enabled ? 'enabled' : 'disabled');
17 | 
18 |         $taggedServices = $container->findTaggedServiceIds($tag);
19 | 
20 |         $providers = [];
21 |         foreach ($taggedServices as $id => $tags) {
22 |             if (!isset($tags[0]['provider_name'])) {
23 |                 throw new \LogicException("Tag parameter 'provider_name' isn't set");
24 |             }
25 | 
26 |             $providers[$tags[0]['provider_name']] = $container->getDefinition($id);
27 |         }
28 | 
29 |         $container->getDefinition('fourxxi_vault.parameter_getter')->addArgument($providers);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/ExpressionLanguage/VaultParameterExpressionLanguageProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ExpressionLanguage;
 4 | 
 5 | use Symfony\Component\ExpressionLanguage\ExpressionFunction;
 6 | use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
 7 | 
 8 | class VaultParameterExpressionLanguageProvider implements ExpressionFunctionProviderInterface
 9 | {
10 |     /**
11 |      * @return ExpressionFunction[] An array of Function instances
12 |      */
13 |     public function getFunctions()
14 |     {
15 |         $compiler = function ($providerName, $fieldName) {
16 |             return sprintf('$this->get(\'fourxxi_vault.parameter_getter\')->get(%1$s, %2$s)', $providerName, $fieldName);
17 |         };
18 | 
19 |         $evaluator = function ($variables, $providerName, $fieldName) {
20 |             return $variables['container']->get('fourxxi_vault.parameter_getter')->get($providerName, $fieldName);
21 |         };
22 | 
23 |         return [
24 |             new ExpressionFunction('v', $compiler, $evaluator),
25 |             new ExpressionFunction('vault', $compiler, $evaluator),
26 |             new ExpressionFunction('fourxxi_vault', $compiler, $evaluator),
27 |         ];
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/ParameterProvider/VaultParameterProviderFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterProvider;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\Client\VaultReaderClientInterface;
 6 | use Fourxxi\Bundle\VaultBundle\ParameterMapper\ParameterMapperInterface;
 7 | use Fourxxi\Bundle\VaultBundle\ParameterMapper\SimpleParameterMapper;
 8 | 
 9 | class VaultParameterProviderFactory
10 | {
11 |     /**
12 |      * @var VaultReaderClientInterface
13 |      */
14 |     protected $vaultClient;
15 | 
16 |     /**
17 |      * VaultParameterProviderFactory constructor.
18 |      *
19 |      * @param VaultReaderClientInterface $vaultClient
20 |      */
21 |     public function __construct(VaultReaderClientInterface $vaultClient)
22 |     {
23 |         $this->vaultClient = $vaultClient;
24 |     }
25 | 
26 |     /**
27 |      * @param string                        $path
28 |      * @param ParameterMapperInterface|null $parameterMapper
29 |      *
30 |      * @return VaultParameterProvider
31 |      */
32 |     public function create(string $path, ParameterMapperInterface $parameterMapper = null)
33 |     {
34 |         $parameterMapper = $parameterMapper ?? new SimpleParameterMapper();
35 | 
36 |         return new VaultParameterProvider($path, $parameterMapper, $this->vaultClient);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Client/VaultClient.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Client;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\Auth\AuthInterface;
 6 | use GuzzleHttp\Client as HttpClient;
 7 | use GuzzleHttp\Psr7\Request;
 8 | 
 9 | class VaultClient implements VaultReaderClientInterface, VaultWriterClientInterface
10 | {
11 |     /**
12 |      * @var HttpClient
13 |      */
14 |     protected $client;
15 | 
16 |     /**
17 |      * Client constructor.
18 |      *
19 |      * @param BaseUriConfigurator $configurator
20 |      */
21 |     public function __construct(AuthInterface $auth, BaseUriConfigurator $baseUriConfigurator)
22 |     {
23 |         $this->client = new HttpClient(
24 |             [
25 |                 'headers' => [
26 |                     'X-Vault-Token' => $auth->getToken(),
27 |                     'Accept' => 'application/json',
28 |                     'Content-Type' => 'application/json',
29 |                 ],
30 |                 'base_uri' => $baseUriConfigurator->getUri(),
31 |             ]
32 |         );
33 |     }
34 | 
35 |     /**
36 |      * {@inheritdoc}
37 |      */
38 |     public function read(string $path)
39 |     {
40 |         $response = $this->client->send(new Request('GET', $path));
41 | 
42 |         return json_decode($response->getBody()->getContents(), true);
43 |     }
44 | 
45 |     /**
46 |      * {@inheritdoc}
47 |      */
48 |     public function write(string $path, array $value)
49 |     {
50 |         $this->client->send(new Request('POST', $path, [], json_encode($value)));
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\DependencyInjection;
 4 | 
 5 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
 6 | use Symfony\Component\Config\Definition\ConfigurationInterface;
 7 | 
 8 | class Configuration implements ConfigurationInterface
 9 | {
10 |     /**
11 |      * {@inheritdoc}
12 |      */
13 |     public function getConfigTreeBuilder()
14 |     {
15 |         $treeBuilder = new TreeBuilder();
16 |         $rootNode = $treeBuilder->root('fourxxi_vault');
17 | 
18 |         $rootNode
19 |             ->children()
20 |                 ->booleanNode('enabled')
21 |                     ->beforeNormalization()
22 |                         ->ifString()
23 |                             ->then(function ($v) {
24 |                                 return in_array($v, ['1', 'true', 'on']);
25 |                             })
26 |                         ->end()
27 |                     ->isRequired()
28 |                 ->end()
29 |                 ->arrayNode('auth')
30 |                     ->children()
31 |                         ->scalarNode('token')->defaultNull()->end()
32 |                     ->end()
33 |                 ->end()
34 |                 ->arrayNode('connection')
35 |                     ->addDefaultsIfNotSet()
36 |                     ->children()
37 |                         ->scalarNode('schema')->defaultValue('https')->end()
38 |                         ->scalarNode('host')->defaultNull()->end()
39 |                         ->scalarNode('port')->defaultValue(8200)->end()
40 |                         ->scalarNode('api_version')->defaultValue('v1')->end()
41 |                     ->end()
42 |                 ->end()
43 |             ->end()
44 |         ;
45 | 
46 |         return $treeBuilder;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |          xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.1/phpunit.xsd"
 5 |          backupGlobals="false"
 6 |          colors="true"
 7 |          bootstrap="vendor/autoload.php"
 8 |          failOnRisky="true"
 9 |          failOnWarning="true"
10 | >
11 |     <php>
12 |         <ini name="error_reporting" value="-1" />
13 |         <env name="KERNEL_CLASS" value="Fourxxi\Bundle\VaultBundle\Tests\Functional\Kernel" />
14 | 
15 |         <env name="vault_token" value="f29e2a2f-26ac-a182-b7a9-05be2381e200" />
16 |         <env name="vault_schema" value="http" />
17 |         <env name="vault_host" value="127.0.0.1" />
18 |         <env name="vault_port" value="8200" />
19 |         <env name="vault_api_version" value="v1" />
20 | 
21 |         <!-- compatibility with symfony 2.8 -->
22 |         <env name="SYMFONY_DEPRECATIONS_HELPER" value="weak" />
23 |         <server name="SYMFONY__env(vault_token)" value="f29e2a2f-26ac-a182-b7a9-05be2381e200" />
24 |         <server name="SYMFONY__env(vault_schema)" value="http" />
25 |         <server name="SYMFONY__env(vault_host)" value="127.0.0.1" />
26 |         <server name="SYMFONY__env(vault_port)" value="8200" />
27 |         <server name="SYMFONY__env(vault_api_version)" value="v1" />
28 |     </php>
29 | 
30 |     <testsuites>
31 |         <testsuite name="unit">
32 |             <directory>./Tests/Unit</directory>
33 |         </testsuite>
34 |         <testsuite name="functional">
35 |             <directory>./Tests/Functional</directory>
36 |         </testsuite>
37 |     </testsuites>
38 | 
39 |     <filter>
40 |         <whitelist>
41 |             <directory>./</directory>
42 |             <exclude>
43 |                 <directory>./Resources</directory>
44 |                 <directory>./Tests</directory>
45 |                 <directory>./vendor</directory>
46 |             </exclude>
47 |         </whitelist>
48 |     </filter>
49 | </phpunit>
50 | 


--------------------------------------------------------------------------------
/DependencyInjection/FourxxiVaultExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\DependencyInjection;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\Auth\TokenAuth;
 6 | use Symfony\Component\Config\FileLocator;
 7 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 8 | use Symfony\Component\DependencyInjection\Definition;
 9 | use Symfony\Component\DependencyInjection\Extension\Extension;
10 | use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
11 | 
12 | class FourxxiVaultExtension extends Extension
13 | {
14 |     /**
15 |      * {@inheritdoc}
16 |      */
17 |     public function load(array $configs, ContainerBuilder $container)
18 |     {
19 |         $loader = new YamlFileLoader(
20 |             $container,
21 |             new FileLocator(__DIR__.'/../Resources/config')
22 |         );
23 | 
24 |         $loader->load('services.yml');
25 | 
26 |         $configuration = new Configuration();
27 |         $config = $this->processConfiguration($configuration, $configs);
28 | 
29 |         $container->setDefinition('fourxxi_vault.auth', $this->getAuthDefinition($config));
30 |         $container->getDefinition('fourxxi_vault.client.base_uri_configurator')->addArgument($config);
31 | 
32 |         $container->setParameter('fourxxi_vault.enabled', $config['enabled']);
33 |     }
34 | 
35 |     /**
36 |      * @param array $config
37 |      *
38 |      * @return Definition
39 |      */
40 |     protected function getAuthDefinition(array $config)
41 |     {
42 |         if ($config['enabled'] === false) {
43 |             return new Definition(TokenAuth::class, ['']);
44 |         }
45 | 
46 |         if (empty($config['auth'])) {
47 |             throw new \LogicException('You should set authentication method');
48 |         }
49 | 
50 |         if (count($config['auth']) > 1) {
51 |             throw new \LogicException('Only one authentication method can be set');
52 |         }
53 | 
54 |         if (isset($config['auth']['token'])) {
55 |             return new Definition(TokenAuth::class, [$config['auth']['token']]);
56 |         }
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Tests/Functional/VaultParameterProviderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Tests\Functional;
 4 | 
 5 | use Symfony\Component\Yaml\Yaml;
 6 | 
 7 | class VaultParameterProviderTest extends VaultWebTestCase
 8 | {
 9 |     /**
10 |      * @dataProvider dataProvider
11 |      */
12 |     public function test(string $path, string $mapper, $input, $output)
13 |     {
14 |         $container = static::$kernel->getContainer();
15 |         $writerClient = $container->get('fourxxi_vault.test.writer_client');
16 |         $writerClient->write($path, $input);
17 | 
18 |         $vaultParameterProviderFactory = $container->get('fourxxi_vault.parameter_provider.vault_factory');
19 | 
20 |         $parameterProvider = $vaultParameterProviderFactory->create(
21 |             $path,
22 |             $container->get(sprintf('fourxxi_vault.test.mapper.%s', $mapper))
23 |         );
24 | 
25 |         $this->assertEquals($parameterProvider->all(), $output);
26 |     }
27 | 
28 |     /**
29 |      * @return string
30 |      */
31 |     protected function getEnvironment(): string
32 |     {
33 |         return 'vault_parameter_test';
34 |     }
35 | 
36 |     /**
37 |      * @return array
38 |      */
39 |     public function dataProvider()
40 |     {
41 |         $mysqlOutput = [
42 |             'mysql_host' => '192.168.0.1',
43 |             'mysql_port' => 3306,
44 |         ];
45 | 
46 |         $elasticsearchOutput = [
47 |             'elasticsearch_host' => '127.0.0.1',
48 |             'elasticsearch_port' => 9200,
49 |         ];
50 | 
51 |         return [
52 |             'simple_mapper' => [
53 |                 'path' => 'secret/mysql',
54 |                 'mapper' => 'simple',
55 |                 'input' => $mysqlOutput,
56 |                 'output' => $mysqlOutput,
57 |             ],
58 |             'yaml_mapper' => [
59 |                 'path' => 'secret/elasticsearch',
60 |                 'mapper' => 'yaml',
61 |                 'input' => [
62 |                     'value' => Yaml::dump($elasticsearchOutput),
63 |                 ],
64 |                 'output' => $elasticsearchOutput,
65 |             ],
66 |         ];
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/ParameterProvider/VaultParameterProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\ParameterProvider;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\Client\VaultReaderClientInterface;
 6 | use Fourxxi\Bundle\VaultBundle\ParameterMapper\ParameterMapperInterface;
 7 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 8 | 
 9 | class VaultParameterProvider implements ParameterProviderInterface
10 | {
11 |     /**
12 |      * @var VaultReaderClientInterface
13 |      */
14 |     protected $vaultClient;
15 | 
16 |     /**
17 |      * @var string
18 |      */
19 |     protected $path;
20 | 
21 |     /**
22 |      * @var ParameterMapperInterface
23 |      */
24 |     protected $parameterMapper;
25 | 
26 |     /**
27 |      * @var ParameterBag
28 |      */
29 |     protected $parameterBag;
30 | 
31 |     /**
32 |      * VaultParameterProvider constructor.
33 |      *
34 |      * @param string                   $path
35 |      * @param ParameterMapperInterface $parameterMapper
36 |      */
37 |     public function __construct(
38 |         string $path,
39 |         ParameterMapperInterface $parameterMapper,
40 |         VaultReaderClientInterface $vaultClient
41 |     ) {
42 |         $this->path = $path;
43 |         $this->vaultClient = $vaultClient;
44 |         $this->parameterMapper = $parameterMapper;
45 |         $this->parameterBag = null;
46 |     }
47 | 
48 |     /**
49 |      * {@inheritdoc}
50 |      */
51 |     public function get($name)
52 |     {
53 |         return $this->getParameterBag()->get($name);
54 |     }
55 | 
56 |     /**
57 |      * {@inheritdoc}
58 |      */
59 |     public function all()
60 |     {
61 |         return $this->getParameterBag()->all();
62 |     }
63 | 
64 |     /**
65 |      * For lazy load parameters.
66 |      *
67 |      * @return ParameterBag
68 |      */
69 |     protected function getParameterBag()
70 |     {
71 |         if ($this->parameterBag === null) {
72 |             $response = $this->vaultClient->read($this->path);
73 |             $this->parameterBag = $this->parameterMapper->map($response);
74 |             $this->parameterBag->resolve();
75 |         }
76 | 
77 |         return $this->parameterBag;
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/Tests/Functional/Kernel.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Fourxxi\Bundle\VaultBundle\Tests\Functional;
 4 | 
 5 | use Fourxxi\Bundle\VaultBundle\FourxxiVaultBundle;
 6 | use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
 7 | use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
 8 | use Symfony\Component\Config\Loader\LoaderInterface;
 9 | use Symfony\Component\DependencyInjection\ContainerBuilder;
10 | use Symfony\Component\HttpKernel\Bundle\BundleInterface;
11 | use Symfony\Component\HttpKernel\Kernel as BaseKernel;
12 | use Symfony\Component\Routing\RouteCollectionBuilder;
13 | 
14 | class Kernel extends BaseKernel
15 | {
16 |     use MicroKernelTrait;
17 | 
18 |     /**
19 |      * Returns an array of bundles to register.
20 |      *
21 |      * @return BundleInterface[] An array of bundle instances
22 |      */
23 |     public function registerBundles()
24 |     {
25 |         return [
26 |             new FrameworkBundle(),
27 |             new FourxxiVaultBundle(),
28 |         ];
29 |     }
30 | 
31 |     /**
32 |      * Add or import routes into your application.
33 |      *
34 |      *     $routes->import('config/routing.yml');
35 |      *     $routes->add('/admin', 'AppBundle:Admin:dashboard', 'admin_dashboard');
36 |      *
37 |      * @param RouteCollectionBuilder $routes
38 |      */
39 |     protected function configureRoutes(RouteCollectionBuilder $routes)
40 |     {
41 |         // TODO: Implement configureRoutes() method.
42 |     }
43 | 
44 |     /**
45 |      * Configures the container.
46 |      *
47 |      * You can register extensions:
48 |      *
49 |      * $c->loadFromExtension('framework', array(
50 |      *     'secret' => '%secret%'
51 |      * ));
52 |      *
53 |      * Or services:
54 |      *
55 |      * $c->register('halloween', 'FooBundle\HalloweenProvider');
56 |      *
57 |      * Or parameters:
58 |      *
59 |      * $c->setParameter('halloween', 'lot of fun');
60 |      *
61 |      * @param ContainerBuilder $c
62 |      * @param LoaderInterface  $loader
63 |      */
64 |     protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader)
65 |     {
66 |         $loader->load(sprintf('%s/Resources/config/config_%s.yml', __DIR__, $this->getEnvironment()));
67 |     }
68 | 
69 |     public function getCacheDir()
70 |     {
71 |         return __DIR__.'/var/cache';
72 |     }
73 | 
74 |     public function getLogDir()
75 |     {
76 |         return __DIR__.'/var/logs';
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Symfony bundle for integration with Vault by HashiCorp 
  2 | ### Badges
  3 | [![Build Develop Status](https://travis-ci.org/4xxi/vault-bundle.svg?branch=develop)](https://travis-ci.org/4xxi/vault-bundle)
  4 | 
  5 | [![SensioLabsInsight](https://insight.sensiolabs.com/projects/d004e03d-ee45-448f-a897-a55fc1522fde/big.png)](https://insight.sensiolabs.com/projects/d004e03d-ee45-448f-a897-a55fc1522fde)
  6 | 
  7 | ### Full configuration
  8 | ```yaml
  9 | fourxxi_vault:
 10 |     enabled: true
 11 |     auth:
 12 |         token: "571f9ef0-583b-cf7a-81af-191c43515c8e"
 13 |     connection:
 14 |         schema: http
 15 |         host: 127.0.0.1
 16 |         port: 8200
 17 |         api_version: 'v1'
 18 | ```
 19 | 
 20 | ### Examples
 21 | ```yaml
 22 |     app.vault.mapper.yaml:
 23 |         class: Fourxxi\Bundle\VaultBundle\ParameterMapper\YamlParameterMapper
 24 |         arguments: ["value"]
 25 | 
 26 |     app.vault.mapper.simple:
 27 |         class: Fourxxi\Bundle\VaultBundle\ParameterMapper\SimpleParameterMapper
 28 | 
 29 |     # for cached parameters
 30 |     app.vault.parameter_provider.elasticsearch:
 31 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\VaultParameterProvider
 32 |         factory: "fourxxi_vault.parameter_provider.vault_factory:create"
 33 |         arguments: ["secret/elasticsearch", "@app.vault.mapper.yaml"]
 34 |         tags:
 35 |             - { name: fourxxi_vault.cached_parameters }
 36 | 
 37 |     app.vault.parameter_provider.mysql:
 38 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\VaultParameterProvider
 39 |         factory: "fourxxi_vault.parameter_provider.vault_factory:create"
 40 |         arguments: ["secret/mysql", "@app.vault.mapper.simple"]
 41 |         tags:
 42 |             - { name: fourxxi_vault.cached_parameters }
 43 |     
 44 |     # For dynamic parameters
 45 |     app.vault.enabled_parameter_provider.elasticsearch:
 46 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\VaultParameterProvider
 47 |         factory: "fourxxi_vault.parameter_provider.vault_factory:create"
 48 |         arguments: ["secret/elasticsearch", "@app.vault.mapper.yaml"]
 49 |         tags:
 50 |             - { name: fourxxi_vault.enabled_parameter_provider, provider_name: 'el' }
 51 | 
 52 |     app.vault.disabled_parameters_provider.elasticsearch:
 53 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\SimpleParameterProvider
 54 |         arguments: ["@=service('service_container').getParameterBag()"]
 55 |         tags:
 56 |             - { name: fourxxi_vault.disabled_parameter_provider, provider_name: 'el' }
 57 | 
 58 |     app.vault.enabled_parameter_provider.mysql:
 59 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\VaultParameterProvider
 60 |         factory: "fourxxi_vault.parameter_provider.vault_factory:create"
 61 |         arguments: ["secret/mysql", "@app.vault.mapper.simple"]
 62 |         tags:
 63 |             - { name: fourxxi_vault.enabled_parameter_provider, provider_name: 'mysql' }
 64 | 
 65 |     app.vault.disabled_parameters_provider.mysql:
 66 |         class: Fourxxi\Bundle\VaultBundle\ParameterProvider\SimpleParameterProvider
 67 |         arguments: ["@=service('service_container').getParameterBag()"]
 68 |         tags:
 69 |             - { name: fourxxi_vault.disabled_parameter_provider, provider_name: 'mysql' }
 70 | 
 71 |     app.test.elasticsearch:
 72 |         class: App\Test
 73 |         public: true
 74 |         arguments:
 75 |             - "@=v('el','elasticsearch_host')"
 76 |             - "@=vault('el','elasticsearch_password')"
 77 |                         
 78 |     app.test.mysql:
 79 |         class: App\Test
 80 |         public: true
 81 |         arguments:
 82 |             - "@=fourxxi_vault('mysql', 'database_pass')"
 83 |             - "@=service('fourxxi_vault.parameter_getter').get('mysql','database_host')"
 84 | ```
 85 | 
 86 | ### Running unit tests:
 87 | ```bash
 88 | ./vendor/bin/phpunit --testsuite unit
 89 | ```
 90 | 
 91 | ### Running functional tests:
 92 | 
 93 | Run vault:
 94 | ```bash
 95 | docker run -d -p 8200:8200 --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=f29e2a2f-26ac-a182-b7a9-05be2381e200' vault
 96 | ```
 97 | 
 98 | Run tests for Symfony 2.8
 99 | ```bash
100 | ./vendor/bin/simple-phpunit --testsuite functional
101 | ```
102 | 
103 | Run tests for Symfony >= 3
104 | ```bash
105 | ./vendor/bin/phpunit --testsuite functional
106 | ```
107 | 
108 | ### @todo
109 | 
110 | 1. Adding more tests
111 | 2. Writing documentation
112 | 


--------------------------------------------------------------------------------