jch-optimize / lib / src / Service / Provider / PageCache.php

PageCache.php in JCH Optimize trunk, at lib/src/Service/Provider/PageCache.php

222 lines 8.6 KB

Raw Download Zip

1	<?php
2
3	/**
4	* JCH Optimize - Performs several front-end optimizations for fast downloads
5	*
6	* @package jchoptimize/core
7	* @author Samuel Marshall <samuel@jch-optimize.net>
8	* @copyright Copyright (c) 2022 Samuel Marshall / JCH Optimize
9	* @license GNU/GPLv3, or later. See LICENSE file
10	*
11	* If LICENSE file missing, see <http://www.gnu.org/licenses/>.
12	*/
13
14	namespace JchOptimize\Core\Service\Provider;
15
16	use _JchOptimizeVendor\V91\Joomla\DI\Container;
17	use _JchOptimizeVendor\V91\Joomla\DI\ServiceProviderInterface;
18	use _JchOptimizeVendor\V91\Joomla\Input\Input;
19	use _JchOptimizeVendor\V91\Laminas\Cache\Pattern\CaptureCache as LaminasCaptureCache;
20	use _JchOptimizeVendor\V91\Laminas\Cache\Storage\StorageInterface;
21	use _JchOptimizeVendor\V91\Laminas\Cache\Storage\TaggableInterface;
22	use _JchOptimizeVendor\V91\Psr\Log\LoggerInterface;
23	use JchOptimize\Core\Cloudflare\CloudflareManager;
24	use JchOptimize\Core\PageCache\CachedResponseEmitter;
25	use JchOptimize\Core\PageCache\CaptureCache as CoreCaptureCache;
26	use JchOptimize\Core\PageCache\CaptureCacheHtaccessManager;
27	use JchOptimize\Core\PageCache\CaptureCachePolicy;
28	use JchOptimize\Core\PageCache\CaptureCacheStore;
29	use JchOptimize\Core\PageCache\CurrentPageResolver;
30	use JchOptimize\Core\PageCache\PageCache as CorePageCache;
31	use JchOptimize\Core\PageCache\PageCacheInvalidator;
32	use JchOptimize\Core\PageCache\PageCacheItemQuery;
33	use JchOptimize\Core\PageCache\PageCacheKeyFactory;
34	use JchOptimize\Core\PageCache\PageCachePolicy;
35	use JchOptimize\Core\PageCache\PageCacheRepository;
36	use JchOptimize\Core\Platform\CacheInterface;
37	use JchOptimize\Core\Platform\HooksInterface;
38	use JchOptimize\Core\Platform\PathsInterface;
39	use JchOptimize\Core\Platform\UtilityInterface;
40	use JchOptimize\Core\Registry;
41	use JchOptimize\Core\SystemUri\SystemUriResolverInterface;
42	use ReflectionClass;
43
44	use function defined;
45
46	use const JCH_PRO;
47
48	defined('_JCH_EXEC') or die('Restricted access');
49
50	class PageCache implements ServiceProviderInterface
51	{
52	public function register(Container $container): void
53	{
54	$container->share(CorePageCache::class, [$this, 'getPageCacheService']);
55	$container->share(CoreCaptureCache::class, [$this, 'getCaptureCacheService']);
56
57	$container->share(CurrentPageResolver::class, [$this, 'getCurrentPageResolverService']);
58	$container->share(PageCacheKeyFactory::class, [$this, 'getPageCacheKeyFactoryService']);
59	$container->set(PageCachePolicy::class, [$this, 'getPageCachePolicyService']);
60	$container->share(PageCacheRepository::class, [$this, 'getPageCacheRepositoryService']);
61	$container->set(PageCacheItemQuery::class, [$this, 'getPageCacheItemQueryService']);
62	$container->share(CachedResponseEmitter::class, [$this, 'getCachedResponseEmitterService']);
63	$container->set(PageCacheInvalidator::class, [$this, 'getPageCacheInvalidatorService']);
64
65	$container->set(CaptureCachePolicy::class, [$this, 'getCaptureCachePolicyService']);
66	$container->share(CaptureCacheStore::class, [$this, 'getCaptureCacheStoreService']);
67	$container->set(CaptureCacheHtaccessManager::class, [$this, 'getCaptureCacheHtaccessManagerService']);
68	}
69
70	/**
71	* @psalm-suppress InvalidArgument
72	*/
73	public function getPageCacheService(Container $container): CorePageCache
74	{
75	if (JCH_PRO) {
76	return $container->get(CoreCaptureCache::class);
77	}
78
79	$pageCache = (new CorePageCache(
80	$container->get(Input::class),
81	$container->get(UtilityInterface::class),
82	$this->getPageCacheAdapterName($container),
83	$container->get(CurrentPageResolver::class),
84	$container->get(PageCacheKeyFactory::class),
85	$container->get(PageCachePolicy::class),
86	$container->get(PageCacheRepository::class),
87	$container->get(PageCacheItemQuery::class),
88	$container->get(CachedResponseEmitter::class),
89	$container->get(PageCacheInvalidator::class)
90	));
91
92	return $pageCache;
93	}
94
95	/**
96	* @psalm-suppress InvalidArgument
97	*/
98	public function getCaptureCacheService(Container $container): CoreCaptureCache
99	{
100	$captureCache = (new CoreCaptureCache(
101	$container->get(Input::class),
102	$container->get(UtilityInterface::class),
103	$this->getPageCacheAdapterName($container),
104	$container->get(CurrentPageResolver::class),
105	$container->get(PageCacheKeyFactory::class),
106	$container->get(PageCachePolicy::class),
107	$container->get(PageCacheRepository::class),
108	$container->get(PageCacheItemQuery::class),
109	$container->get(CachedResponseEmitter::class),
110	$container->get(PageCacheInvalidator::class),
111	$container->get(CaptureCacheStore::class),
112	$container->get(CaptureCachePolicy::class),
113	$container->get(CaptureCacheHtaccessManager::class)
114	));
115
116	return $captureCache;
117	}
118
119	public function getCurrentPageResolverService(Container $container): CurrentPageResolver
120	{
121	return new CurrentPageResolver(
122	$container->get(Registry::class),
123	$container->get(SystemUriResolverInterface::class)
124	);
125	}
126
127	public function getPageCacheKeyFactoryService(Container $container): PageCacheKeyFactory
128	{
129	return new PageCacheKeyFactory(
130	$container->get(Registry::class),
131	$container->get(HooksInterface::class),
132	$container->get(UtilityInterface::class),
133	$this->getPageCacheAdapterName($container)
134	);
135	}
136
137	public function getPageCachePolicyService(Container $container): PageCachePolicy
138	{
139	return new PageCachePolicy(
140	$container->get(Registry::class),
141	$container->get(Input::class),
142	$container->get('page_cache'),
143	$container->get(CacheInterface::class),
144	$container->get(HooksInterface::class),
145	$container->get(UtilityInterface::class),
146	$container->get(CurrentPageResolver::class)
147	);
148	}
149
150	public function getPageCacheRepositoryService(Container $container): PageCacheRepository
151	{
152	return new PageCacheRepository(
153	$container->get('page_cache'),
154	$container->get(TaggableInterface::class),
155	$this->getPageCacheAdapterName($container),
156	fn(string $adapter): StorageInterface => $container->get($adapter)
157	);
158	}
159
160	public function getPageCacheItemQueryService(Container $container): PageCacheItemQuery
161	{
162	return new PageCacheItemQuery($container->get(PageCacheRepository::class));
163	}
164
165	public function getCachedResponseEmitterService(Container $container): CachedResponseEmitter
166	{
167	return new CachedResponseEmitter($container->get(CacheInterface::class));
168	}
169
170	public function getPageCacheInvalidatorService(Container $container): PageCacheInvalidator
171	{
172	return new PageCacheInvalidator(
173	$container->get(PageCacheRepository::class),
174	null,
175	$container->get(CloudflareManager::class)
176	);
177	}
178
179	public function getCaptureCachePolicyService(Container $container): CaptureCachePolicy
180	{
181	return new CaptureCachePolicy(
182	$container->get(Registry::class),
183	$container->get(Input::class),
184	$container->get(CacheInterface::class),
185	$container->get(UtilityInterface::class),
186	$container->get(CurrentPageResolver::class)
187	);
188	}
189
190	public function getCaptureCacheStoreService(Container $container): CaptureCacheStore
191	{
192	$store = new CaptureCacheStore(
193	$container->get(LaminasCaptureCache::class),
194	$container->get(PathsInterface::class),
195	$container->get(CurrentPageResolver::class),
196	$container->get(Registry::class),
197	$container->get(UtilityInterface::class)
198	);
199	$store->setLogger($container->get(LoggerInterface::class));
200
201	return $store;
202	}
203
204	public function getCaptureCacheHtaccessManagerService(Container $container): CaptureCacheHtaccessManager
205	{
206	return new CaptureCacheHtaccessManager(
207	$container->get(Registry::class),
208	$container->get(CacheInterface::class),
209	$container->get(PathsInterface::class),
210	$container->get(CaptureCachePolicy::class),
211	$container->get(UtilityInterface::class)
212	);
213	}
214
215	private function getPageCacheAdapterName(Container $container): string
216	{
217	$reflection = new ReflectionClass($container->get('page_cache'));
218
219	return $reflection->getShortName();
220	}
221	}
222