SuperCacheInvalidationHelper::getCacheInvalidationEventsProcessedPartitionName() - Code Metrics - Inspection of "use partition" - padosoft/laravel-super-cache-invalidate - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — main (#3)

unknown
created 2025-01-02 13:03 UTC
getCacheInvalidationEventsProcessedPartitionName() A

↳ Parent: SuperCacheInvalidationHelper
Complexity

Conditions	6
Paths	6
Size

Total Lines	24
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
cc	6
eloc	14
nc	6
nop	3
dl	0
loc	24
rs	9.2222
c	2
b	0
f	0
<?php

namespace Padosoft\SuperCacheInvalidate\Helpers;

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Redis;
use Illuminate\Support\Carbon;

class SuperCacheInvalidationHelper
{
    /**
     * Insert a cache invalidation event into the database.
     *
     * @param string      $type                  'key' or 'tag'
     * @param string      $identifier            The cache key or tag to invalidate
     * @param string|null $connection_name       The Redis Connection name (optional, 'default')
     * @param string|null $reason                Reason for invalidation (optional)
     * @param int|null    $totalShards           Total number of shards (from config if null)
     * @param int|null    $priority              Priority of the event
     * @param array|null  $associatedIdentifiers Optional array of associated tags or keys
     */
    public function insertInvalidationEvent(
        string $type,
        string $identifier,
        ?string $connection_name = null,
        ?string $reason = null,
        ?int $totalShards = 0,
        ?int $priority = 0,
        ?array $associatedIdentifiers = [],
        /** @scrutinizer ignore-unused */ ?array $associatedIdentifiers = [],
    ): void {
        $shard = crc32($identifier) % ($totalShards > 0 ? $totalShards : config('super_cache_invalidate.total_shards', 10));

        $redisConnectionName = $connection_name ?? config('super_cache_invalidate.default_connection_name');
        $data = [
            'type' => $type,
            'identifier' => $identifier,
            'connection_name' => $redisConnectionName,
            'reason' => $reason,
            'priority' => $priority,
            'event_time' => now(),
            'processed' => 0,
            'shard' => $shard,
        ];

        $maxAttempts = 5;
        $attempts = 0;
        $insertOk = false;

        while ($attempts < $maxAttempts && !$insertOk) {
            //DB::beginTransaction();

            try {
                // Cerca di bloccare il record per l'inserimento
                $partitionCache_invalidation_events = $this->getCacheInvalidationEventsPartitionName($shard, $priority);
                $partitionCache_invalidation_events = $this->getCacheInvalidationEventsPartitionName($shard, /** @scrutinizer ignore-type */ $priority);

                //$eventId = DB::table(DB::raw("`cache_invalidation_events` PARTITION ({$partitionCache_invalidation_events})"))->insertGetId($data);
                DB::table(DB::raw("`cache_invalidation_events` PARTITION ({$partitionCache_invalidation_events})"))->insert($data);
                // Insert associated identifiers
                // TODO JB 31/12/2024: per adesso commentato, da riattivare quando tutto funziona alla perfezione usando la partizione,
                // anche perchè la chiave primaria è data da id e partiton_key, per cui va capito cosa restituisce insertGetId e se è bloccante
                /*
                if (!empty($associatedIdentifiers)) {
                    $associations = [];
                    foreach ($associatedIdentifiers as $associated) {
                        $associations[] = [
                            'event_id' => $eventId,
                            'associated_type' => $associated['type'], // 'key' or 'tag'
                            'associated_identifier' => $associated['identifier'],
                            'connection_name' => $associated['connection_name'],
                            'created_at' => now(),
                        ];
                    }
                    DB::table('cache_invalidation_event_associations')->insert($associations);
                }
                */
                $insertOk = true;
                //DB::commit(); // Completa la transazione
            } catch (\Throwable $e) {
                //DB::rollBack(); // Annulla la transazione in caso di errore
                $attempts++;
                Log::error("SuperCacheInvalidate: impossibile eseguire insert, tentativo $attempts di $maxAttempts: " . $e->getMessage());
                // Logica per gestire i tentativi falliti
                if ($attempts >= $maxAttempts) {
                    // Salta il record dopo il numero massimo di tentativi
                    Log::error("SuperCacheInvalidate: impossibile eseguire insert dopo $maxAttempts tentativi: " . $e->getMessage());
                }
            }
        }
    }

    /**
     * Acquire a lock for processing a shard.
     *
     * @param  int          $shardId         The shard number
     * @param  int          $lockTimeout     Lock timeout in seconds
     * @param  string       $connection_name The Redis Connection name
     * @return string|false The lock value if acquired, false otherwise
     */
    public function acquireShardLock(int $shardId, int $priority, int $lockTimeout, string $connection_name): bool|string
    {
        $lockKey = 'shard_lock:' . $shardId . '_' . $priority;
        // Il metodo has/exists occupa troppa memoria!!!
        $retrieveValue = Redis::connection($connection_name)->get($lockKey);
        if ($retrieveValue !== null) {
            // Lock già attivo
            return false;
        }
        $lockValue = uniqid('', true);
        $isLocked = Redis::connection($connection_name)->set($lockKey, $lockValue);

        if ($lockTimeout > 0) {
            Redis::connection($connection_name)->expire($lockKey, $lockTimeout);
        }

        return $isLocked ? $lockValue : false;
    }

    /**
     * Release the lock for a shard.
     *
     * @param int    $shardId         The shard number
     * @param string $lockValue       The lock value to validate ownership
     * @param string $connection_name The Redis Connection name
     */
    public function releaseShardLock(int $shardId, int $priority, string $lockValue, string $connection_name): void
    {
        $lockKey = 'shard_lock:' . $shardId . '_' . $priority;
        $currentValue = Redis::connection($connection_name)->get($lockKey);
        if ($currentValue === $lockValue) {
            Redis::connection($connection_name)->del($lockKey);
        }
    }

    public function getCacheInvalidationEventsPartitionName(int $shardId, int $priorityId): string
    {
        // Calcola il valore della partizione
        $shards = config('super_cache_invalidate.total_shards', 10);
        $priorities = [0, 1];

        $partitionValueId = ($priorityId * $shards) + $shardId + 1;

        // Partitions for unprocessed events
        foreach ($priorities as $priority) {
            for ($shard = 0; $shard < $shards; $shard++) {
                $partitionName = "p_unprocessed_s{$shard}_p{$priority}";
                $partitionValue = ($priority * $shards) + $shard + 1;
                if ($partitionValueId < $partitionValue) {
                    return $partitionName;
                }
            }
        }

        return '';
    }

    public function getCacheInvalidationTimestampsPartitionName(Carbon $event_time): string
    public function getCacheInvalidationTimestampsPartitionName(/** @scrutinizer ignore-unused */ Carbon $event_time): string
    {
        $now = now();
        $partitionValueId = ($now->year * 100 + $now->weekOfYear) + 1;
        $startYear = 2024;
        $endYear = 2030;

        for ($year = $startYear; $year <= $endYear; $year++) {
            for ($week = 1; $week <= 53; $week++) {
                $partitionName = "p_{$year}w{$week}";
                $partitionValue = ($year * 100 + $week) + 1;
                if ($partitionValueId < $partitionValue) {
                    return $partitionName;
                }
            }
        }

        return '';
    }

    public function getCacheInvalidationEventsProcessedPartitionName(int $shardId, int $priorityId, string $event_time): string
    {
        // Calcola il valore della partizione
        $shards = config('super_cache_invalidate.total_shards', 10);
        $priorities = [0, 1];
        $eventTime = Carbon::parse($event_time);
        $partitionValueId = ($eventTime->year * 10000) + ($eventTime->weekOfYear * 100) + ($priorityId * $shards) + $shardId;
        // Partitions for processed events
        for ($year = $eventTime->year; $year <= ($eventTime->year + 1); $year++) {
            for ($week = $eventTime->weekOfYear; $week <= $eventTime->weekOfYear + 1; $week++) {
                foreach ($priorities as $priority) {
                    for ($shard = 0; $shard < $shards; $shard++) {
                        $partitionKey = ($year * 10000) + ($week * 100) + ($priority * $shards) + $shard;
                        $partitionValue = $partitionKey + 1;
                        $partitionName = "p_s{$shard}_p{$priority}_{$year}w{$week}";
                        if ($partitionValueId < $partitionValue) {
                            return $partitionName;
                        }
                    }
                }
            }
        }

        return '';
    }
}

padosoft / laravel-super-cache-invalidate

Pull Request — main (#3)

getCacheInvalidationEventsProcessedPartitionName() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
