SuperCacheInvalidationHelper::insertInvalidationEvent() - 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 2024-12-31 13:55 UTC

insertInvalidationEvent() B

↳ Parent: SuperCacheInvalidationHelper

Complexity

Conditions	8
Paths	36

Size

Total Lines	57
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	8
eloc	35
c	2
b	0
f	0
nc	36
nop	7
dl	0
loc	57
rs	8.1155

How to fix Long Method

<?php

namespace Padosoft\SuperCacheInvalidate\Helpers;

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

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 = [],
    ): 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
                $eventId = DB::table('cache_invalidation_events')->insertGetId($data);

                // Insert associated identifiers
                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++;
                // 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);
        }
    }
}


1			<?php
2
3			namespace Padosoft\SuperCacheInvalidate\Helpers;
4
5			use Illuminate\Support\Facades\DB;
6			use Illuminate\Support\Facades\Log;
7			use Illuminate\Support\Facades\Redis;
8
9			class SuperCacheInvalidationHelper
10			{
11			/**
12			* Insert a cache invalidation event into the database.
13			*
14			* @param string $type 'key' or 'tag'
15			* @param string $identifier The cache key or tag to invalidate
16			* @param string\|null $connection_name The Redis Connection name (optional, 'default')
17			* @param string\|null $reason Reason for invalidation (optional)
18			* @param int\|null $totalShards Total number of shards (from config if null)
19			* @param int\|null $priority Priority of the event
20			* @param array\|null $associatedIdentifiers Optional array of associated tags or keys
21			*/
22			public function insertInvalidationEvent(
23			string $type,
24			string $identifier,
25			?string $connection_name = null,
26			?string $reason = null,
27			?int $totalShards = 0,
28			?int $priority = 0,
29			?array $associatedIdentifiers = [],
30			): void {
31			$shard = crc32($identifier) % ($totalShards > 0 ? $totalShards : config('super_cache_invalidate.total_shards', 10));
32
33			$redisConnectionName = $connection_name ?? config('super_cache_invalidate.default_connection_name');
34			$data = [
35			'type' => $type,
36			'identifier' => $identifier,
37			'connection_name' => $redisConnectionName,
38			'reason' => $reason,
39			'priority' => $priority,
40			'event_time' => now(),
41			'processed' => 0,
42			'shard' => $shard,
43			];
44
45			$maxAttempts = 5;
46			$attempts = 0;
47			$insertOk = false;
48
49			while ($attempts < $maxAttempts && !$insertOk) {
50			DB::beginTransaction();
51
52			try {
53			// Cerca di bloccare il record per l'inserimento
54			$eventId = DB::table('cache_invalidation_events')->insertGetId($data);
55
56			// Insert associated identifiers
57			if (!empty($associatedIdentifiers)) {
58			$associations = [];
59			foreach ($associatedIdentifiers as $associated) {
60			$associations[] = [
61			'event_id' => $eventId,
62			'associated_type' => $associated['type'], // 'key' or 'tag'
63			'associated_identifier' => $associated['identifier'],
64			'connection_name' => $associated['connection_name'],
65			'created_at' => now(),
66			];
67			}
68			DB::table('cache_invalidation_event_associations')->insert($associations);
69			}
70			$insertOk = true;
71			DB::commit(); // Completa la transazione
72			} catch (\Throwable $e) {
73			DB::rollBack(); // Annulla la transazione in caso di errore
74			$attempts++;
75			// Logica per gestire i tentativi falliti
76			if ($attempts >= $maxAttempts) {
77			// Salta il record dopo il numero massimo di tentativi
78			Log::error("SuperCacheInvalidate: impossibile eseguire insert dopo $maxAttempts tentativi: " . $e->getMessage());
79			}
80			}
81			}
82			}
83
84			/**
85			* Acquire a lock for processing a shard.
86			*
87			* @param int $shardId The shard number
88			* @param int $lockTimeout Lock timeout in seconds
89			* @param string $connection_name The Redis Connection name
90			* @return string\|false The lock value if acquired, false otherwise
91			*/
92			public function acquireShardLock(int $shardId, int $priority, int $lockTimeout, string $connection_name): bool\|string
93			{
94			$lockKey = 'shard_lock:' . $shardId . '_' . $priority;
95			// Il metodo has/exists occupa troppa memoria!!!
96			$retrieveValue = Redis::connection($connection_name)->get($lockKey);
97			if ($retrieveValue !== null) {
98			// Lock già attivo
99			return false;
100			}
101			$lockValue = uniqid('', true);
102			$isLocked = Redis::connection($connection_name)->set($lockKey, $lockValue);
103
104			if ($lockTimeout > 0) {
105			Redis::connection($connection_name)->expire($lockKey, $lockTimeout);
106			}
107
108			return $isLocked ? $lockValue : false;
109			}
110
111			/**
112			* Release the lock for a shard.
113			*
114			* @param int $shardId The shard number
115			* @param string $lockValue The lock value to validate ownership
116			* @param string $connection_name The Redis Connection name
117			*/
118			public function releaseShardLock(int $shardId, int $priority, string $lockValue, string $connection_name): void
119			{
120			$lockKey = 'shard_lock:' . $shardId . '_' . $priority;
121			$currentValue = Redis::connection($connection_name)->get($lockKey);
122			if ($currentValue === $lockValue) {
123			Redis::connection($connection_name)->del($lockKey);
124			}
125			}
126			}
127

padosoft / laravel-super-cache-invalidate

Pull Request — main (#3)

insertInvalidationEvent() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like