ProcessCacheInvalidationEventsCommand::processEvents()

Complexity

Conditions	11
Paths	22

Size

Total Lines	58
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

<?php
    protected function processEvents(): void
    {
        $processingStartTime = now();
        // Recupero gli eventi da invalidare
        $events = $this->getEventsToInvalidate($processingStartTime);
        $this->logIf('Trovati ' . count($events) . ' Eventi da invalidare');
        if (count($events) === 0) {
            return;
        }

        // Creiamo un array per memorizzare il valore più vecchio per ogni coppia (type, identifier) così elimino i doppioni che si sono accumulati nel tempo di apertura della finestra
        $unique_events = [];

        foreach ($events as $event) {
            $key = $event->type . ':' . $event->identifier; // Chiave univoca per type + identifier
            $event->event_time = \Illuminate\Support\Carbon::parse($event->event_time);
            // Quando la chiave non esiste o il nuovo valore ha un event_time più vecchio, lo sostituisco così a parità di tag ho sempre quello più vecchio e mi baso su quello per verificare la finestra
            if (!isset($unique_events[$key]) || $event->event_time <= $unique_events[$key]->event_time) {
                $unique_events[$key] = $event;
            }
        }

        $unique_events = array_values($unique_events);

        $this->logIf('Eventi unici ' . count($unique_events));
        // Quando il numero di eventi unici è inferiore al batchSize e quello più vecchio aspetta da almeno due minuti, mando l'invalidazione.
        // Questo serve per i siti piccoli che hanno pochi eventi, altrimenti si rischia di attendere troppo per invalidare i tags
        // In questo caso invalido i tag/key "unici" e setto a processed = 1 tutti quelli recuperati
        if (count($unique_events) < $this->tagBatchSize && $processingStartTime->diffInSeconds($unique_events[0]->event_time) >= 120) {
            $this->logIf('Il numero di eventi unici è inferiore al batchSize ( ' . $this->tagBatchSize . ' ) e sono passati più di due minuti, procedo');
            $this->processBatch($events, $unique_events);

            return;
        }

        // Altrimenti ho raggiunto il tagbatchsize e devo prendere solo quelli che hanno la finestra di invalidazione attiva
        $eventsToUpdate = [];
        $eventsAll = [];
        foreach ($unique_events as $event) {
            $elapsed = $processingStartTime->diffInSeconds($event->event_time, true);
            $typeFilter = $event->type;
            $identifierFilter = $event->identifier;
            if ($elapsed < $this->invalidation_window) {
                // Se la richiesta (cmq del più vecchio) non è nella finestra di invalidazione salto l'evento
                continue;
            }
            // altrimenti aggiungo l'evento a quelli da processare
            $eventsToUpdate[] = $event;
            // e recupero tutti gli ID che hanno quel tag/key
            $eventsAll[] = array_filter($events, function ($event) use ($typeFilter, $identifierFilter) {
                return $event->type === $typeFilter && $event->identifier === $identifierFilter;
            });
        }
        if (count($eventsToUpdate) === 0) {
            return;
        }

        $this->processBatch(array_merge(...$eventsAll), $eventsToUpdate);
    }