21240912360

Committed 22 Jan 2026 08:10AM UTC coverage: 47.727% (-4.2%) from 51.887%

Build # 21240912360

Build Type

push

github

Committed by

leeqvip

Commit Message

feat: add clearCache

Run Details

3 of 22 new or added lines in 3 files covered. (13.64%)

11 existing lines in 2 files now uncovered.

105 of 220 relevant lines covered (47.73%)

5.37 hits per line

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

5.17

/src/Apollo.php

<?php

declare(strict_types=1);

namespace Leeqvip\Apollo;

use GuzzleHttp\Exception\GuzzleException;
use Leeqvip\Apollo\Exceptions\ApolloException;
use Leeqvip\Apollo\Parsers\Parser;

/**
 * Apollo client core class
 */
class Apollo
{
    /**
     * Instance
     * @var Apollo|null
     */
    protected static ?Apollo $instance = null;

    /**
     * Configuration management
     * @var Config
     */
    protected Config $config;

    /**
     * Apollo server communication client
     * @var Client
     */
    protected Client $client;

    /**
     * Configuration
     * @var array<string, mixed>
     */
    protected array $options;

    /**
     * Namespace list
     * @var array<string>
     */
    protected array $namespaces = ['application'];

    protected string $defaultNamespace = 'application';

    /**
     * Cache directory
     * @var string
     */
    protected string $cacheDir;

    /**
     * Constructor
     *
     * @param array<string, mixed> $options Configuration parameters
     * @throws ApolloException
     * @throws GuzzleException
     */
    protected function __construct(array $options)
    {
        $this->options = $options;
        $this->config = new Config();
        $this->client = new Client($options);
        $this->namespaces = $options['namespaces'] ?? $this->namespaces;
        $this->defaultNamespace = count($this->namespaces) > 0 ? $this->namespaces[0] : $this->defaultNamespace;
        $this->cacheDir = $options['cache_dir'] ?? sys_get_temp_dir() . '/apollo';

        // Initialize
        $this->init();
    }

    /**
     * Get instance (singleton pattern)
     *
     * @param array<string, mixed> $options Configuration parameters
     * @return Apollo
     * @throws ApolloException|GuzzleException
     */
    public static function getInstance(array $options = []): Apollo
    {
        if (!self::$instance) {
            self::$instance = new self($options);
        }
        return self::$instance;
    }

    /**
     * Initialize
     * @return void
     * @throws ApolloException|GuzzleException
     */
    private function init(): void
    {
        // Ensure cache directory exists
        if (!is_dir($this->cacheDir)) {
            mkdir($this->cacheDir, 0755, true);
        }
        $this->loadOrPull();
    }

    /**
     * @throws GuzzleException
     * @throws ApolloException
     */
    private function loadOrPull(): void
    {
        // Load cache
        if ($this->loadCache()) {
            return;
        }

        $this->pullConfigs();
    }

    /**
     * @throws ApolloException
     * @throws GuzzleException
     */
    public function pull(): void
    {
        $this->pullConfigs();
    }

    /**
     * Pull configurations
     *
     * @return void
     * @throws ApolloException
     * @throws GuzzleException
     */
    protected function pullConfigs(): void
    {
        foreach ($this->namespaces as $namespace) {
            $configString = $this->client->getConfig($namespace);
            $config = $this->parse($configString, $namespace);
            $this->config->setBatch($config, $namespace);
            $this->saveCache($namespace, $config);
        }
    }

    protected function parse(string $content, string $namespace): array
    {
        $parser = Parser::create($namespace);
        return $parser->parse($content);
    }

    /**
     *
     * Get config instance
     *
     * @return Config
     */
    public function getConfig(): Config
    {
        return $this->config;
    }

    /**
     * Get configuration
     *
     * @param string $key Configuration key
     * @param mixed $default Default value
     * @param string|null $namespace Namespace
     * @return mixed
     */
    public function get(string $key, mixed $default = null, ?string $namespace = null): mixed
    {
        return $this->config->get($key, $default, empty($namespace) ? $this->defaultNamespace : $namespace);
    }

    /**
     * Get all configurations
     *
     * @param string|null $namespace Namespace
     * @return array<string, mixed>
     */
    public function all(?string $namespace = null): array
    {
        return $this->config->all(empty($namespace) ? $this->defaultNamespace : $namespace);
    }

    /**
     * Register configuration change callback
     *
     * @param callable $callback Callback function
     * @param string $namespace Namespace
     * @return void
     */
    public function onUpdate(callable $callback, string $namespace = '*'): void
    {
        $this->config->registerCallback($callback, $namespace);
    }

    /**
     * Start listening for configuration changes
     *
     * @param callable|null $callback Change callback
     * @return void
     */
    public function listen(?callable $callback = null): void
    {
        while (true) {
            $notifications = $this->client->listenConfig($this->namespaces);
            if (!empty($notifications)) {
                foreach ($notifications as $notification) {
                    ['namespaceName' => $namespace, 'notificationId' => $notificationId] = $notification;
                    $config = $this->client->getConfigImmediately($namespace);

                    $this->config->setBatch($config, $namespace);
                    $this->saveCache($namespace, $config);
                    // notificationId
                    $this->client->setNotificationId($namespace, $notificationId);

                    if ($callback) {
                        call_user_func($callback, $config, $namespace);
                    }
                }
            }
        }
    }

    /**
     * Load from local cache
     *
     * @return bool
     */
    protected function loadCache(): bool
    {
        foreach ($this->namespaces as $namespace) {
            $cacheFile = $this->getCacheFile($namespace);
            if (!file_exists($cacheFile)) {
                return false;
            }
            $config = require $cacheFile;
            if (!is_array($config)) {
                return false;
            }
            $this->config->setBatch($config, $namespace);
        }

        return true;
    }

    /**
     * Save cache
     *
     * @param string $namespace Namespace
     * @param array<string, mixed> $config Configuration
     * @return void
     */
    protected function saveCache(string $namespace, array $config): void
    {
        $cacheFile = $this->getCacheFile($namespace);
        $content = "<?php\n\nreturn " . var_export($config, true) . ";\n";
        file_put_contents($cacheFile, $content);
    }

    /**
     * @param string $namespace
     * @return void
     */
    public function removeCache(string $namespace = '*'): void
    {
        foreach ($this->namespaces as $namespace) {
            $cacheFile = $this->getCacheFile($namespace);
            if (file_exists($cacheFile)) {
                unlink($cacheFile);
            }
        }
    }

    /**
     * Get cache file path
     *
     * @param string $namespace Namespace
     * @return string
     */
    protected function getCacheFile(string $namespace): string
    {
        return $this->cacheDir . '/' . md5($this->options['app_id'] . '_' . $namespace) . '.php';
    }

    /**
     * Disable cloning
     */
    public function __clone(): void
    {
    }

    /**
     * Disable serialization
     */
    public function __wakeup(): void
    {
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Leeqvip\Apollo;
6
7	use GuzzleHttp\Exception\GuzzleException;
8	use Leeqvip\Apollo\Exceptions\ApolloException;
9	use Leeqvip\Apollo\Parsers\Parser;
10
11	/**
12	* Apollo client core class
13	*/
14	class Apollo
15	{
16	/**
17	* Instance
18	* @var Apollo\|null
19	*/
20	protected static ?Apollo $instance = null;
21
22	/**
23	* Configuration management
24	* @var Config
25	*/
26	protected Config $config;
27
28	/**
29	* Apollo server communication client
30	* @var Client
31	*/
32	protected Client $client;
33
34	/**
35	* Configuration
36	* @var array<string, mixed>
37	*/
38	protected array $options;
39
40	/**
41	* Namespace list
42	* @var array<string>
43	*/
44	protected array $namespaces = ['application'];
45
46	protected string $defaultNamespace = 'application';
47
48	/**
49	* Cache directory
50	* @var string
51	*/
52	protected string $cacheDir;
53
54	/**
55	* Constructor
56	*
57	* @param array<string, mixed> $options Configuration parameters
58	* @throws ApolloException
59	* @throws GuzzleException
60	*/
61	protected function __construct(array $options)
62	{
UNCOV 63	$this->options = $options;	×
UNCOV 64	$this->config = new Config();	×
UNCOV 65	$this->client = new Client($options);	×
UNCOV 66	$this->namespaces = $options['namespaces'] ?? $this->namespaces;	×
UNCOV 67	$this->defaultNamespace = count($this->namespaces) > 0 ? $this->namespaces[0] : $this->defaultNamespace;	×
UNCOV 68	$this->cacheDir = $options['cache_dir'] ?? sys_get_temp_dir() . '/apollo';	×
69
70	// Initialize
UNCOV 71	$this->init();	×
72	}
73
74	/**
75	* Get instance (singleton pattern)
76	*
77	* @param array<string, mixed> $options Configuration parameters
78	* @return Apollo
79	* @throws ApolloException\|GuzzleException
80	*/
81	public static function getInstance(array $options = []): Apollo
82	{
83	if (!self::$instance) {	12✔
UNCOV 84	self::$instance = new self($options);	×
85	}
86	return self::$instance;	12✔
87	}
88
89	/**
90	* Initialize
91	* @return void
92	* @throws ApolloException\|GuzzleException
93	*/
94	private function init(): void
95	{
96	// Ensure cache directory exists
UNCOV 97	if (!is_dir($this->cacheDir)) {	×
UNCOV 98	mkdir($this->cacheDir, 0755, true);	×
99	}
NEW 100	$this->loadOrPull();	×
101	}
102
103	/**
104	* @throws GuzzleException
105	* @throws ApolloException
106	*/
107	private function loadOrPull(): void
108	{
109	// Load cache
NEW 110	if ($this->loadCache()) {	×
NEW 111	return;	×
112	}
113
114	$this->pullConfigs();	×
115	}
116
117	/**
118	* @throws ApolloException
119	* @throws GuzzleException
120	*/
121	public function pull(): void
122	{
NEW 123	$this->pullConfigs();	×
124	}
125
126	/**
127	* Pull configurations
128	*
129	* @return void
130	* @throws ApolloException
131	* @throws GuzzleException
132	*/
133	protected function pullConfigs(): void
134	{
135	foreach ($this->namespaces as $namespace) {	×
136	$configString = $this->client->getConfig($namespace);	×
137	$config = $this->parse($configString, $namespace);	×
138	$this->config->setBatch($config, $namespace);	×
139	$this->saveCache($namespace, $config);	×
140	}
141	}
142
143	protected function parse(string $content, string $namespace): array
144	{
145	$parser = Parser::create($namespace);	×
146	return $parser->parse($content);	×
147	}
148
149	/**
150	*
151	* Get config instance
152	*
153	* @return Config
154	*/
155	public function getConfig(): Config
156	{
157	return $this->config;	×
158	}
159
160	/**
161	* Get configuration
162	*
163	* @param string $key Configuration key
164	* @param mixed $default Default value
165	* @param string\|null $namespace Namespace
166	* @return mixed
167	*/
168	public function get(string $key, mixed $default = null, ?string $namespace = null): mixed
169	{
170	return $this->config->get($key, $default, empty($namespace) ? $this->defaultNamespace : $namespace);	6✔
171	}
172
173	/**
174	* Get all configurations
175	*
176	* @param string\|null $namespace Namespace
177	* @return array<string, mixed>
178	*/
179	public function all(?string $namespace = null): array
180	{
NEW 181	return $this->config->all(empty($namespace) ? $this->defaultNamespace : $namespace);	×
182	}
183
184	/**
185	* Register configuration change callback
186	*
187	* @param callable $callback Callback function
188	* @param string $namespace Namespace
189	* @return void
190	*/
191	public function onUpdate(callable $callback, string $namespace = '*'): void
192	{
193	$this->config->registerCallback($callback, $namespace);	×
194	}
195
196	/**
197	* Start listening for configuration changes
198	*
199	* @param callable\|null $callback Change callback
200	* @return void
201	*/
202	public function listen(?callable $callback = null): void
203	{
204	while (true) {	×
205	$notifications = $this->client->listenConfig($this->namespaces);	×
206	if (!empty($notifications)) {	×
207	foreach ($notifications as $notification) {	×
208	['namespaceName' => $namespace, 'notificationId' => $notificationId] = $notification;	×
209	$config = $this->client->getConfigImmediately($namespace);	×
210
211	$this->config->setBatch($config, $namespace);	×
212	$this->saveCache($namespace, $config);	×
213	// notificationId
214	$this->client->setNotificationId($namespace, $notificationId);	×
215
216	if ($callback) {	×
217	call_user_func($callback, $config, $namespace);	×
218	}
219	}
220	}
221	}
222	}
223
224	/**
225	* Load from local cache
226	*
227	* @return bool
228	*/
229	protected function loadCache(): bool
230	{
231	foreach ($this->namespaces as $namespace) {	×
232	$cacheFile = $this->getCacheFile($namespace);	×
NEW 233	if (!file_exists($cacheFile)) {	×
NEW 234	return false;	×
235	}
NEW 236	$config = require $cacheFile;	×
NEW 237	if (!is_array($config)) {	×
NEW 238	return false;	×
239	}
NEW 240	$this->config->setBatch($config, $namespace);	×
241	}
242
NEW 243	return true;	×
244	}
245
246	/**
247	* Save cache
248	*
249	* @param string $namespace Namespace
250	* @param array<string, mixed> $config Configuration
251	* @return void
252	*/
253	protected function saveCache(string $namespace, array $config): void
254	{
255	$cacheFile = $this->getCacheFile($namespace);	×
NEW 256	$content = "<?php\n\nreturn " . var_export($config, true) . ";\n";	×
NEW 257	file_put_contents($cacheFile, $content);	×
258	}
259
260	/**
261	* @param string $namespace
262	* @return void
263	*/
264	public function removeCache(string $namespace = '*'): void
265	{
NEW 266	foreach ($this->namespaces as $namespace) {	×
NEW 267	$cacheFile = $this->getCacheFile($namespace);	×
NEW 268	if (file_exists($cacheFile)) {	×
NEW 269	unlink($cacheFile);	×
270	}
271	}
272	}
273
274	/**
275	* Get cache file path
276	*
277	* @param string $namespace Namespace
278	* @return string
279	*/
280	protected function getCacheFile(string $namespace): string
281	{
NEW 282	return $this->cacheDir . '/' . md5($this->options['app_id'] . '_' . $namespace) . '.php';	×
283	}
284
285	/**
286	* Disable cloning
287	*/
288	public function __clone(): void
289	{
290	}	×
291
292	/**
293	* Disable serialization
294	*/
295	public function __wakeup(): void
296	{
297	}	×
298	}

leeqvip / php-apollo / 21240912360

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