Cache things in memory instead

No need for file caching as long octane is used.

.env.dusk.local.example

···
 DB_DATABASE_UPDATES=osu_updates_test
 
 ES_INDEX_PREFIX=test_
-
-CACHE_DRIVER_LOCAL=array

.env.example

···
 
 BROADCAST_DRIVER=log
 CACHE_DRIVER=file
-# CACHE_DRIVER_LOCAL=file
 SESSION_DRIVER=file
 # SESSION_DOMAIN=
 # SESSION_SECURE_COOKIE=false

.github/workflows/tests.yml

···
   APP_KEY: base64:q7U5qyAkedR1F6UhN0SQlUxBpAMDyfHy3NNFkqmiMqA=
   APP_URL: http://localhost:8000
   CACHE_DRIVER: redis
-  CACHE_DRIVER_LOCAL: array
   DB_HOST: 127.0.0.1
   DB_USERNAME: root
   ES_SOLO_SCORES_HOST: http://localhost:9200

app/Libraries/ChatFilters.php

···
 namespace App\Libraries;
 
 use App\Models\ChatFilter;
-use App\Traits\LocallyCached;
+use App\Traits\Memoizes;
 use Illuminate\Database\Eloquent\Collection;
 
 class ChatFilters
 {
-    use LocallyCached;
+    use Memoizes;
+
+    public function __construct()
+    {
+        app('local-cache-manager')->registerCallback(fn () => $this->resetMemoized());
+    }
 
     public function all()
     {
-        return $this->cachedMemoize(__FUNCTION__, fn () => $this->fetch());
+        return $this->memoize(__FUNCTION__, fn () => $this->fetch());
     }
 
     protected function fetch(): Collection

app/Libraries/Groups.php

···
 namespace App\Libraries;
 
 use App\Models\Group;
-use App\Traits\LocallyCached;
 use Exception;
 use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Database\Eloquent\ModelNotFoundException;
+use App\Traits\Memoizes;
 
 class Groups
 {
-    use LocallyCached;
+    use Memoizes;
+
+    public function __construct()
+    {
+        app('local-cache-manager')->registerCallback(fn () => $this->resetMemoized());
+    }
 
     /**
      * Get all groups.
      */
     public function all(): Collection
     {
-        return $this->cachedMemoize(__FUNCTION__, fn () => $this->fetch());
+        return $this->memoize(__FUNCTION__, fn () => $this->fetch());
     }
 
     /**

app/Libraries/LocalCacheManager.php

···
+<?php
+
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
+// See the LICENCE file in the repository root for full licence text.
+
+declare(strict_types=1);
+
+namespace App\Libraries;
+
+class LocalCacheManager
+{
+    private int $resetTicker = 0;
+    private int $resetTickerLimit;
+    private array $callbacks = [];
+
+    public function incrementResetTicker(): void
+    {
+        $this->resetTicker++;
+        $this->resetTickerLimit ??= config('osu.octane.local_cache_reset_requests');
+
+        if ($this->resetTicker > $this->resetTickerLimit) {
+            $this->resetTicker = 0;
+            $this->resetCache();
+        }
+    }
+
+    public function registerCallback(callable $callback)
+    {
+        $this->callbacks[] = $callback;
+    }
+
+    private function resetCache(): void
+    {
+        foreach ($this->callbacks as $callback) {
+            $callback();
+        }
+    }
+}

app/Listeners/OctaneResetLocalCache.php

···
 {
     public function handle($event): void
     {
-        app('chat-filters')->incrementResetTicker();
-        app('groups')->incrementResetTicker();
+        app('local-cache-manager')->incrementResetTicker();
     }
 }

app/Providers/AppServiceProvider.php

···
 use App\Libraries\CleanHTML;
 use App\Libraries\Groups;
 use App\Libraries\LayoutCache;
+use App\Libraries\LocalCacheManager;
 use App\Libraries\Mods;
 use App\Libraries\MorphMap;
 use App\Libraries\OsuAuthorize;
···
         'clean-html' => CleanHTML::class,
         'groups' => Groups::class,
         'layout-cache' => LayoutCache::class,
+        'local-cache-manager' => LocalCacheManager::class,
         'mods' => Mods::class,
         'route-section' => RouteSection::class,
         'score-pins' => ScorePins::class,
···
 
         Queue::after(function (JobProcessed $event) {
             app('OsuAuthorize')->resetCache();
-            app('groups')->incrementResetTicker();
-            app('chat-filters')->incrementResetTicker();
+            app('local-cache-manager')->incrementResetTicker();
 
             Datadog::increment(
                 config('datadog-helper.prefix_web').'.queue.run',

app/Traits/LocallyCached.php

···
-<?php
-
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the GNU Affero General Public License v3.0.
-// See the LICENCE file in the repository root for full licence text.
-
-namespace App\Traits;
-
-/**
- * Nested caching to reduce large request defined in "fetch" function
- * of whatever using this trait.
- *
- * Memoizes trait is included and reset accordingly.
- *
- * Use cachedMemoize to locally cache the callback's return (in addition to memoizing it).
- * Use resetCache to force reset on all instances.
- * Use forceVersionCheck to ensure version check on next memoize usage.
- */
-trait LocallyCached
-{
-    use Memoizes {
-        Memoizes::memoize as unversionedMemoize;
-    }
-
-    private int $resetTicker = 0;
-    private int $resetTickerLimit;
-    private ?int $version = null;
-    private bool $versionCheck = false;
-
-    private static function getVersionCacheKey(): string
-    {
-        return 'local_cache_v2:'.static::class.':version';
-    }
-
-    private static function getCurrentVersion(): int
-    {
-        $cacheKey = static::getVersionCacheKey();
-        $cache = cache();
-        $version = $cache->get($cacheKey);
-
-        if ($version === null) {
-            $version = hrtime(true);
-            $cache->put($cacheKey, $version, 300);
-        }
-
-        return $version;
-    }
-
-    public function resetCache(): void
-    {
-        cache()->put(static::getVersionCacheKey(), hrtime(true));
-
-        $this->forceVersionCheck();
-    }
-
-    public function forceVersionCheck(): void
-    {
-        $this->versionCheck = true;
-    }
-
-    public function incrementResetTicker(): void
-    {
-        $this->resetTicker++;
-        $this->resetTickerLimit ??= config('osu.octane.local_cache_reset_requests');
-
-        if ($this->resetTicker > $this->resetTickerLimit) {
-            $this->forceVersionCheck();
-            $this->resetTicker = 0;
-        }
-    }
-
-    protected function cachedMemoize(string $memoizeKey, callable $function)
-    {
-        return $this->memoize($memoizeKey, function () use ($function, $memoizeKey) {
-            $cache = cache()->store(config('cache.local'));
-            $key = 'local_cache:'.static::class.':'.$memoizeKey;
-            $value = $cache->get($key);
-
-            if ($value === null || $value['version'] !== $this->version) {
-                $value = [
-                    'data' => $function(),
-                    'version' => $this->version,
-                ];
-                $cache->forever($key, $value);
-            }
-
-            return $value['data'];
-        });
-    }
-
-    protected function memoize(string $key, callable $function)
-    {
-        $this->validateVersion();
-
-        return $this->unversionedMemoize($key, $function);
-    }
-
-    private function validateVersion(): void
-    {
-        if ($this->version !== null && !$this->versionCheck) {
-            return;
-        }
-
-        $this->versionCheck = false;
-        $currentVersion = static::getCurrentVersion();
-
-        if ($this->version !== null && $this->version !== $currentVersion) {
-            $this->resetMemoized();
-        }
-
-        $this->version = $currentVersion;
-    }
-}

config/cache.php

···
     */
 
     'default' => env('CACHE_DRIVER', 'file'),
-    'local' => env('CACHE_DRIVER_LOCAL', 'file'),
 
     /*
     |--------------------------------------------------------------------------

phpunit.xml

···
         <env name="BEATMAPSET_REQUIRED_HYPE" value="0"/>
         <env name="BROADCAST_DRIVER" value="log"/>
         <env name="CACHE_DRIVER" value="array"/>
-        <env name="CACHE_DRIVER_LOCAL" value="array"/>
         <env name="CHAT_PRIVATE_LIMIT" value="2"/>
         <env name="SESSION_DRIVER" value="array"/>