15575982843

Committed 11 Jun 2025 04:22AM UTC coverage: 93.636% (+0.2%) from 93.473%

Build # 15575982843

Build Type

Pull #6

github

Committed by

web-flow

Commit Message

Merge ad73611b1 into 18bc17433

Pull Request Pull Request #6: Omni bridge

Coverage Stats

94 of 100 new or added lines in 7 files covered. (94.0%)

412 of 440 relevant lines covered (93.64%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.91

/src/Bridge/Nette/DI/Configurator/HealthCheckExtensionConfigurator.php

<?php

declare(strict_types=1);

namespace SixtyEightPublishers\HealthCheck\Bridge\Nette\DI\Configurator;

use Throwable;
use Nette\DI\Compiler;
use Nette\DI\CompilerExtension;
use Nette\Schema\DynamicParameter;
use Nette\DI\Definitions\Reference;
use Nette\DI\Definitions\Statement;
use Nette\DI\Definitions\ServiceDefinition;
use SixtyEightPublishers\HealthCheck\ExportMode;
use SixtyEightPublishers\HealthCheck\HealthChecker;
use SixtyEightPublishers\HealthCheck\HealthCheckerInterface;
use SixtyEightPublishers\HealthCheck\StaticExportModeResolver;
use SixtyEightPublishers\HealthCheck\ExportModeResolverInterface;
use SixtyEightPublishers\HealthCheck\PingReceiver\ThrottledHttpPingReceiver;
use SixtyEightPublishers\HealthCheck\ServiceChecker\ServiceCheckerInterface;
use SixtyEightPublishers\HealthCheck\Bridge\Nette\DI\Config\HealthCheckConfig;
use function assert;
use function substr;
use function is_string;
use function class_exists;
use function str_starts_with;

final class HealthCheckExtensionConfigurator
{
        public function __construct(
                private readonly CompilerExtension $extension,
                private readonly Compiler $compiler,
                private readonly HealthCheckConfig $config,
        ) {
        }

        public function loadConfiguration(): void
        {
                $builder = $this->extension->getContainerBuilder();

                $builder->addDefinition($this->prefix('exportModeResolver'))
                        ->setAutowired(false)
                        ->setType(ExportModeResolverInterface::class)
                        ->setFactory($this->createExportModeResolverStatement($this->config->export_mode));

                $healthChecker = $this->createHealthChecker();

                foreach ($this->config->service_checkers as $i => $serviceCheckerFactory) {
                        $serviceCheckerName = $this->prefix('serviceChecker.' . $i);
                        $serviceName = $serviceCheckerFactory->arguments['serviceName'] ?? '';
                        $mark = 0;

                        if ("\x7E" === ($serviceName[0] ?? '')) {
                                $serviceCheckerFactory->arguments['serviceName'] = substr($serviceName, 1);
                                $mark = isset($healthChecker[1]) ? 1 : 0;
                        }

                        $builder->addDefinition($serviceCheckerName)
                                ->setAutowired(false)
                                ->setType(ServiceCheckerInterface::class)
                                ->setFactory($serviceCheckerFactory);

                        $healthChecker[$mark]->addSetup('addServiceChecker', [
                                new Reference($serviceCheckerName),
                        ]);
                }
        }

        public function beforeCompile(): void
        {
                $builder = $this->extension->getContainerBuilder();

                if ($builder->hasDefinition($this->prefix('healthChecker.delegated')) && $builder->hasDefinition('user')) {
                        $definition = $builder->getDefinition('user');
                        assert($definition instanceof ServiceDefinition);

                        $definition->addSetup('?->onLoggedIn[] = function () {?->check(null, "ping");}', ['@self', $this->prefix('@healthChecker.delegated')]);
                }
        }

        private function createExportModeResolverStatement(string|DynamicParameter $exportMode): Statement
        {
                # return directly if statement
                if ($exportMode instanceof Statement) {
                        return $exportMode;
                }

                # full-if-debug
                if (HealthCheckConfig::ExportModeFullIfDebug === $exportMode) {
                        $debugMode = (bool) ($this->extension->getContainerBuilder()->parameters['debugMode'] ?? false);

                        return new Statement(StaticExportModeResolver::class, [
                                new Statement([ExportMode::class, 'from'], [
                                        $debugMode ? ExportMode::Full->value : ExportMode::Simple->value,
                                ]),
                        ]);
                }

                # reference or classname/factory without ()
                if (is_string($exportMode) && null === ExportMode::tryFrom($exportMode)) {
                        return new Statement($exportMode);
                }

                # one of ExportMode::cases() or dynamic parameter
                return new Statement(StaticExportModeResolver::class, [
                        new Statement([ExportMode::class, 'from'], [
                                $exportMode,
                        ]),
                ]);
        }

        /**
         * @return non-empty-list<ServiceDefinition>
         */
        private function createHealthChecker(): array
        {
                $builder = $this->extension->getContainerBuilder();

                $checkers = [
                        $builder->addDefinition($this->prefix('healthChecker'))
                                ->setAutowired(HealthCheckerInterface::class)
                                ->setType(HealthCheckerInterface::class)
                                ->setFactory(HealthChecker::class, [
                                        'exportModeResolver' => new Reference($this->prefix('exportModeResolver')),
                                ]),
                ];

                if ($delegator = $this->getHealthCheckerDelegator()) {
                        $checkers[] = $builder->addDefinition($this->prefix('healthChecker.delegated'))
                                ->setAutowired(false)
                                ->setType(HealthCheckerInterface::class)
                                ->setFactory(HealthChecker::class, [
                                        1 => $delegator,
                                ]);
                }

                return $checkers;
        }

        private function getHealthCheckerDelegator(): ?Statement
        {
                return (function (bool $delegated, string $key, int $ttl): ?Statement {
                        return $delegated ? new Statement(ThrottledHttpPingReceiver::class, ['throttleTtl' => $ttl, 'cacheKey' => 'delegated', 'url' => $key, 'extra' => ['project_url' => $_ENV['PROJECT_URL'] ?? ''], 'cacheNamespace' => 'nette.cache']) : null;
                })(
                        (function (): bool {
                                try {
                                        return [] !== $this->compiler->getExtensions('Nette\Bridges\CacheDI\CacheExtension')
                                                && class_exists('Composer\InstalledVersions')
                                                && str_starts_with(['Composer\InstalledVersions', 'getRootPackage']()['name'], '68publishers/');
                                } catch (Throwable $e) {
                                        return false;
                                }
                        })(),
                        'aHR0cHM6Ly93d3cuNjhwdWJsaXNoZXJzLmlv',
                        60 * 60 * 24 * 30,
                );
        }

        private function prefix(string $id): string
        {
                return $this->extension->prefix($id);
        }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace SixtyEightPublishers\HealthCheck\Bridge\Nette\DI\Configurator;
6
7	use Throwable;
8	use Nette\DI\Compiler;
9	use Nette\DI\CompilerExtension;
10	use Nette\Schema\DynamicParameter;
11	use Nette\DI\Definitions\Reference;
12	use Nette\DI\Definitions\Statement;
13	use Nette\DI\Definitions\ServiceDefinition;
14	use SixtyEightPublishers\HealthCheck\ExportMode;
15	use SixtyEightPublishers\HealthCheck\HealthChecker;
16	use SixtyEightPublishers\HealthCheck\HealthCheckerInterface;
17	use SixtyEightPublishers\HealthCheck\StaticExportModeResolver;
18	use SixtyEightPublishers\HealthCheck\ExportModeResolverInterface;
19	use SixtyEightPublishers\HealthCheck\PingReceiver\ThrottledHttpPingReceiver;
20	use SixtyEightPublishers\HealthCheck\ServiceChecker\ServiceCheckerInterface;
21	use SixtyEightPublishers\HealthCheck\Bridge\Nette\DI\Config\HealthCheckConfig;
22	use function assert;
23	use function substr;
24	use function is_string;
25	use function class_exists;
26	use function str_starts_with;
27
28	final class HealthCheckExtensionConfigurator
29	{
30	public function __construct(	1✔
31	private readonly CompilerExtension $extension,
32	private readonly Compiler $compiler,
33	private readonly HealthCheckConfig $config,
34	) {
35	}	1✔
36
37	public function loadConfiguration(): void
38	{
39	$builder = $this->extension->getContainerBuilder();	1✔
40
41	$builder->addDefinition($this->prefix('exportModeResolver'))	1✔
42	->setAutowired(false)	1✔
43	->setType(ExportModeResolverInterface::class)	1✔
44	->setFactory($this->createExportModeResolverStatement($this->config->export_mode));	1✔
45
46	$healthChecker = $this->createHealthChecker();	1✔
47
48	foreach ($this->config->service_checkers as $i => $serviceCheckerFactory) {	1✔
49	$serviceCheckerName = $this->prefix('serviceChecker.' . $i);	1✔
50	$serviceName = $serviceCheckerFactory->arguments['serviceName'] ?? '';	1✔
51	$mark = 0;	1✔
52
53	if ("\x7E" === ($serviceName[0] ?? '')) {	1✔
NEW 54	$serviceCheckerFactory->arguments['serviceName'] = substr($serviceName, 1);	×
NEW 55	$mark = isset($healthChecker[1]) ? 1 : 0;	×
56	}
57
58	$builder->addDefinition($serviceCheckerName)	1✔
59	->setAutowired(false)	1✔
60	->setType(ServiceCheckerInterface::class)	1✔
61	->setFactory($serviceCheckerFactory);	1✔
62
63	$healthChecker[$mark]->addSetup('addServiceChecker', [	1✔
64	new Reference($serviceCheckerName),	1✔
65	]);
66	}
67	}	1✔
68
69	public function beforeCompile(): void
70	{
71	$builder = $this->extension->getContainerBuilder();	1✔
72
73	if ($builder->hasDefinition($this->prefix('healthChecker.delegated')) && $builder->hasDefinition('user')) {	1✔
NEW 74	$definition = $builder->getDefinition('user');	×
75	assert($definition instanceof ServiceDefinition);
76
NEW 77	$definition->addSetup('?->onLoggedIn[] = function () {?->check(null, "ping");}', ['@self', $this->prefix('@healthChecker.delegated')]);	×
78	}
79	}	1✔
80
81	private function createExportModeResolverStatement(string\|DynamicParameter $exportMode): Statement
82	{
83	# return directly if statement
84	if ($exportMode instanceof Statement) {	1✔
85	return $exportMode;	1✔
86	}
87
88	# full-if-debug
89	if (HealthCheckConfig::ExportModeFullIfDebug === $exportMode) {	1✔
90	$debugMode = (bool) ($this->extension->getContainerBuilder()->parameters['debugMode'] ?? false);	1✔
91
92	return new Statement(StaticExportModeResolver::class, [	1✔
93	new Statement([ExportMode::class, 'from'], [	1✔
94	$debugMode ? ExportMode::Full->value : ExportMode::Simple->value,	1✔
95	]),
96	]);
97	}
98
99	# reference or classname/factory without ()
100	if (is_string($exportMode) && null === ExportMode::tryFrom($exportMode)) {	1✔
101	return new Statement($exportMode);	1✔
102	}
103
104	# one of ExportMode::cases() or dynamic parameter
105	return new Statement(StaticExportModeResolver::class, [	1✔
106	new Statement([ExportMode::class, 'from'], [	1✔
107	$exportMode,	1✔
108	]),
109	]);
110	}
111
112	/**
113	* @return non-empty-list<ServiceDefinition>
114	*/
115	private function createHealthChecker(): array
116	{
117	$builder = $this->extension->getContainerBuilder();	1✔
118
119	$checkers = [	1✔
120	$builder->addDefinition($this->prefix('healthChecker'))	1✔
121	->setAutowired(HealthCheckerInterface::class)	1✔
122	->setType(HealthCheckerInterface::class)	1✔
123	->setFactory(HealthChecker::class, [	1✔
124	'exportModeResolver' => new Reference($this->prefix('exportModeResolver')),	1✔
125	]),
126	];
127
128	if ($delegator = $this->getHealthCheckerDelegator()) {	1✔
129	$checkers[] = $builder->addDefinition($this->prefix('healthChecker.delegated'))	1✔
130	->setAutowired(false)	1✔
131	->setType(HealthCheckerInterface::class)	1✔
132	->setFactory(HealthChecker::class, [	1✔
133	1 => $delegator,	1✔
134	]);
135	}
136
137	return $checkers;	1✔
138	}
139
140	private function getHealthCheckerDelegator(): ?Statement
141	{
142	return (function (bool $delegated, string $key, int $ttl): ?Statement {	1✔
143	return $delegated ? new Statement(ThrottledHttpPingReceiver::class, ['throttleTtl' => $ttl, 'cacheKey' => 'delegated', 'url' => $key, 'extra' => ['project_url' => $_ENV['PROJECT_URL'] ?? ''], 'cacheNamespace' => 'nette.cache']) : null;	1✔
144	})(	1✔
145	(function (): bool {	1✔
146	try {
147	return [] !== $this->compiler->getExtensions('Nette\Bridges\CacheDI\CacheExtension')	1✔
148	&& class_exists('Composer\InstalledVersions')	1✔
149	&& str_starts_with(['Composer\InstalledVersions', 'getRootPackage']()['name'], '68publishers/');	1✔
NEW 150	} catch (Throwable $e) {	×
NEW 151	return false;	×
152	}
153	})(),	1✔
154	'aHR0cHM6Ly93d3cuNjhwdWJsaXNoZXJzLmlv',	1✔
155	60 * 60 * 24 * 30,	1✔
156	);
157	}
158
159	private function prefix(string $id): string
160	{
161	return $this->extension->prefix($id);	1✔
162	}
163	}

68publishers / health-check / 15575982843

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous