DatiCollezionatiDistributedRedisAtomicLong.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */
  20. package org.openspcoop2.pdd.core.controllo_traffico.policy.driver.redisson.counters;

  22. import java.util.ArrayList;
  23. import java.util.Date;
  24. import java.util.List;

  26. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  27. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  28. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicyMapId;
  29. import org.openspcoop2.core.controllo_traffico.beans.IDatiCollezionatiDistributed;
  30. import org.openspcoop2.core.controllo_traffico.constants.TipoControlloPeriodo;
  31. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.BuilderDatiCollezionatiDistributed;
  32. import org.openspcoop2.utils.SemaphoreLock;
  33. import org.redisson.api.RedissonClient;
  34. import org.slf4j.Logger;


  37. /**
  38.  * Scelgo questa implementazione, dove la versione distribuita eredita da DatiCollezionati e replica i dati da distribuitre.
  39.  * In questo modo, le varie PolicyGroupByActiveThreads* continueranno a restituire un oggetto di tipo DatiCollezionati. Con dati che sono presenti
  40.  * nella ram del nodo locale, evitando così che il PolicyVerifier o altre classi che utilizzano i DatiCollezionatiDistributed vadano 
  41.  * a fare richieste remote, ottenendo valori che non sono quelli che ci si aspettava dopo la richiesta.
  42.  * 
  43.  * @author Francesco Scarlato (scarlato@link.it)
  44.  * @author $Author$
  45.  * @version $Rev$, $Date$
  46.  *
  47.  */
  48. public class DatiCollezionatiDistributedRedisAtomicLong extends DatiCollezionati implements IDatiCollezionatiDistributed{

  50.     private static final long serialVersionUID = 1L;
  51.     
  52.     private final transient org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("DatiCollezionatiDistributedRedisAtomicLong");
  53.     
  54.     private final transient RedissonClient redisson;
  55.     private final IDUnivocoGroupByPolicyMapId groupByPolicyMapId;
  56.     private final int groupByPolicyMapIdHashCode;

  58.     // data di registrazione/aggiornamento policy
  59.     
  60.     // final: sono i contatori che non dipendono da una finestra temporale
  61.     
  62.     // sono rimasti AtomicLong le date
  63.     private final transient DatoRAtomicLong distributedUpdatePolicyDate; // data di ultima modifica della policy
  64.     private final transient DatoRAtomicLong distributedPolicyDate; // intervallo corrente su cui vengono costruiti gli altri contatori

  66.     private transient DatoRAtomicLong distributedPolicyRequestCounter;  // numero di richieste effettuato nell'intervallo
  67.     private transient DatoRAtomicLong distributedPolicyCounter; // utilizzato per tempi o banda
  68.     
  69.     private final transient DatoRAtomicLong distributedPolicyDegradoPrestazionaleDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  70.     private transient  DatoRAtomicLong distributedPolicyDegradoPrestazionaleRequestCounter; // numero di richieste effettuato nell'intervallo
  71.     private transient DatoRAtomicLong distributedPolicyDegradoPrestazionaleCounter; // contatore del degrado

  73.     private final boolean distribuitedActiveRequestCounterPolicyRichiesteSimultanee;
  74.     private final transient DatoRAtomicLong distributedActiveRequestCounterForStats; // numero di richieste simultanee
  75.     private transient DatoRAtomicLong distributedActiveRequestCounterForCheck; // numero di richieste simultanee
  76.     
  77.     private transient DatoRAtomicLong distributedPolicyDenyRequestCounter; // policy bloccate
  78.     
  79.     // I contatori da eliminare 
  80.     // Se si effettua il drop di un contatore quando si rileva il cambio di intervallo, potrebbe succedere che in un altro nodo del cluster che sta effettuando la fase di 'end'
  81.     // non rilevi più il contatore e di fatto quindi lo riprende partenzo da 0. Poi a sua volta capisce il cambio di intervallo e lo rielimina.
  82.     // per questo motivo, il drop viene effettuato al secondo cambio di intervallo, e ad ogni cambio i contatori vengono collezionati nel cestino
  83.     private transient List<DatoRAtomicLong> cestinoPolicyCounters = new ArrayList<>();
  84.     private transient List<DatoRAtomicLong> cestinoPolicyCountersDegradoPrestazionale = new ArrayList<>();
  85.     
  86.     private boolean initialized = false;

  88.     public DatiCollezionatiDistributedRedisAtomicLong(Logger log, Date updatePolicyDate, Date gestorePolicyConfigDate, RedissonClient redisson, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  89.         super(updatePolicyDate, gestorePolicyConfigDate);
  90.     
  91.         this.redisson = redisson;
  92.         this.groupByPolicyMapId = groupByPolicyMapId;
  93.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  94.         
  95.         this.initDatiIniziali(activePolicy);
  96.         this.checkDate(log, activePolicy); // inizializza le date se ci sono
  97.         
  98.         this.distributedPolicyDate = this.initPolicyDate();
  99.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  100.         
  101.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();
  102.         
  103.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  104.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  105.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  106.             this.distributedActiveRequestCounterForCheck = this.initActiveRequestCounters();
  107.             this.distributedActiveRequestCounterForStats = null;
  108.         }
  109.         else {
  110.             this.distributedActiveRequestCounterForStats = this.initActiveRequestCounters();
  111.         }
  112.         
  113.         if(this.policyRealtime!=null && this.policyRealtime){
  114.             initPolicyCounters(super.getPolicyDate().getTime());
  115.         }
  116.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  117.             initPolicyCountersDegradoPrestazionale(super.getPolicyDegradoPrestazionaleDate().getTime());
  118.         }
  119.         
  120.         // Gestisco la updatePolicyDate qui.
  121.         // se updatePolicyDate è > this.distributedUpdatePolicyDate.get() allora resetto i contatori del cluster e setto la nuova data distribuita.
  122.         // Questo per via di come funziona l'aggiornamento delle policy: i datiCollezionati correnti per una map<IDUnivoco..., DatiCollezionati> vengono cancellati e reinizializzati.
  123.         // Per gli altri nodi in esecuzione, la updatePolicyDate locale resta sempre la stessa, ma non viene usata.
  124.         if(this.policyRealtime!=null && this.policyRealtime &&
  125.             updatePolicyDate != null && this.distributedUpdatePolicyDate!=null && this.distributedUpdatePolicyDate.get() < updatePolicyDate.getTime()) {
  126.             this.resetCounters(updatePolicyDate);
  127.         }
  128.         
  129.         this.initialized = true;
  130.     }
  131.         
  132.     public DatiCollezionatiDistributedRedisAtomicLong(Logger log, DatiCollezionati dati, RedissonClient redisson, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  133.         super(dati.getUpdatePolicyDate(), dati.getGestorePolicyConfigDate());
  134.         
  135.         if(log!=null) {
  136.             // nop
  137.         }
  138.         
  139.         // Inizializzo il padre con i valori in RAM, dopo uso 'super' per essere  sicuro di usare quelli
  140.         dati.setValuesIn(this, false);
  141.         
  142.         this.redisson = redisson;
  143.         this.groupByPolicyMapId = groupByPolicyMapId;
  144.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  145.         
  146.         this.distributedPolicyDate = this.initPolicyDate();
  147.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  148.         
  149.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();
  150.         
  151.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  152.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  153.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  154.             this.distributedActiveRequestCounterForCheck = this.initActiveRequestCounters();
  155.             this.distributedActiveRequestCounterForStats = null;
  156.         }
  157.         else {
  158.             this.distributedActiveRequestCounterForStats = this.initActiveRequestCounters();
  159.         }
  160.         

  162.         // Se non ho la policyDate, non considero il resto delle informazioni, che senza di essa non hanno senso.
  163.         if (super.getPolicyDate() != null) {

  165.             // Non serve: essendo già persistente, si va a sommare un dato gia' esistente
  166.             /**
  167.             
  168.             // Se ci sono altri nodi che stanno andando, la distributedPolicyDate DEVE essere != 0 
  169.             if (this.distributedPolicyDate.compareAndSet(0, super.getPolicyDate().getTime())) {
  170.                 // Se la data distribuita non era inizializzata e questo nodo l'ha settata, imposto i contatori come da immagine bin.
  171.                 //  Faccio la addAndGet, in quanto tutti valori positivi, non entriamo in conflitto con gli altri nodi che stanno effettuando lo startup nello stesso momento
  172.                 
  173.                 Long polDate = super.getPolicyDate().getTime();
  174.                 initPolicyCounters(polDate);
  175.                                 
  176.                 Long getPolicyRequestCounter = super.getPolicyRequestCounter(true);
  177.                 if (getPolicyRequestCounter != null) {
  178.                     this.distributedPolicyRequestCounter.addAndGet(getPolicyRequestCounter);
  179.                 }
  180.                 
  181.                 Long getPolicyDenyRequestCounter = super.getPolicyDenyRequestCounter(true);
  182.                 if (getPolicyDenyRequestCounter != null) {
  183.                     this.distributedPolicyDenyRequestCounter.set(getPolicyDenyRequestCounter);
  184.                 }
  185.                 
  186.                 if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){ 
  187.                     Long getPolicyCounter = super.getPolicyCounter(true);
  188.                     if (getPolicyCounter != null) {
  189.                         this.distributedPolicyCounter.addAndGet(getPolicyCounter);
  190.                     }
  191.                 }
  192.                 
  193.                 Long getActiveRequestCounter = super.getActiveRequestCounter(true);
  194.                 if (getActiveRequestCounter!=null && getActiveRequestCounter != 0) {
  195.                     if(this.distribuitedActiveRequestCounter_policyRichiesteSimultanee){
  196.                         this.distributedActiveRequestCounterForCheck.set(getActiveRequestCounter);
  197.                     }
  198.                     else {
  199.                         this.distributedActiveRequestCounterForStats.set(getActiveRequestCounter);
  200.                     }
  201.                 }
  202.                                         
  203.             } else {
  204.             */
  205.                 Long polDate = this.distributedPolicyDate!=null ? this.distributedPolicyDate.get() : null;
  206.                 initPolicyCounters(polDate);
  207.                 
  208.             /**}*/
  209.         }
  210.         
  211.         // Se non ho la policyDegradoPrestazionaleDate, non considero il resto delle informazioni, che senza di essa non hanno senso.
  212.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime &&
  213.             super.getPolicyDegradoPrestazionaleDate() != null) {
  214.                 
  215.             // Non serve: essendo già persistente, si va a sommare un dato gia' esistente
  216.             /**
  217.             // Imposto i contatori distribuiti solo se nel frattempo non l'ha fatto un altro thread del cluster.
  218.             if (this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(0, super.getPolicyDegradoPrestazionaleDate().getTime())) {
  219.                 
  220.                 Long degradoPrestazionaleTime = super.getPolicyDegradoPrestazionaleDate().getTime();
  221.                 initPolicyCountersDegradoPrestazionale(degradoPrestazionaleTime);
  222.                 
  223.                 Long getPolicyDegradoPrestazionaleRequestCounter = super.getPolicyDegradoPrestazionaleRequestCounter(true);
  224.                 if (getPolicyDegradoPrestazionaleRequestCounter != null) {
  225.                     this.distributedPolicyDegradoPrestazionaleRequestCounter.addAndGet(getPolicyDegradoPrestazionaleRequestCounter);
  226.                 }
  227.                 
  228.                 Long getPolicyDegradoPrestazionaleCounter = super.getPolicyDegradoPrestazionaleCounter(true);
  229.                 if (getPolicyDegradoPrestazionaleCounter != null) {
  230.                     this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(getPolicyDegradoPrestazionaleCounter);
  231.                 }
  232.                 
  233.             }  else {
  234.             */  
  235.                 Long degradoPrestazionaleTime = this.distributedPolicyDegradoPrestazionaleDate!=null ? this.distributedPolicyDegradoPrestazionaleDate.get() : null;
  236.                 initPolicyCountersDegradoPrestazionale(degradoPrestazionaleTime);
  237.                 
  238.             /**}*/

  240.         }
  241.         
  242.         this.initialized = true;
  243.     }
  244.     
  245.     private DatoRAtomicLong initPolicyDate() {
  246.         if(this.policyRealtime!=null && this.policyRealtime){
  247.             return new DatoRAtomicLong(this.redisson,
  248.                     this.groupByPolicyMapIdHashCode+
  249.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DATE+
  250.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  251.         }
  252.         return null;
  253.     }
  254.     private DatoRAtomicLong initUpdatePolicyDate() {
  255.         if(this.policyRealtime!=null && this.policyRealtime){
  256.             return new DatoRAtomicLong(this.redisson,
  257.                     this.groupByPolicyMapIdHashCode
  258.                     +BuilderDatiCollezionatiDistributed.DISTRUBUITED_UPDATE_POLICY_DATE+
  259.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  260.         }
  261.         return null;
  262.     }
  263.     private DatoRAtomicLong initPolicyDegradoPrestazionaleDate() {
  264.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  265.             return new DatoRAtomicLong(this.redisson,
  266.                     this.groupByPolicyMapIdHashCode+
  267.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DEGRADO_PRESTAZIONALE_DATE+
  268.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  269.         }
  270.         return null;
  271.     }
  272.     
  273.     private DatoRAtomicLong initActiveRequestCounters() {
  274.         return new DatoRAtomicLong(this.redisson,
  275.                 this.groupByPolicyMapIdHashCode+
  276.                 BuilderDatiCollezionatiDistributed.DISTRUBUITED_ACTIVE_REQUEST_COUNTER+
  277.                 (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  278.     }
  279.     
  280.     private void initPolicyCounters(Long policyDate) {

  282.         if(this.policyRealtime!=null && this.policyRealtime){
  283.                         
  284.             this.distributedPolicyRequestCounter = new DatoRAtomicLong(this.redisson,
  285.                     this.groupByPolicyMapIdHashCode+
  286.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_REQUEST_COUNTER+
  287.                     policyDate+
  288.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  289.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  290.             
  291.             this.distributedPolicyDenyRequestCounter = new DatoRAtomicLong(this.redisson,
  292.                     this.groupByPolicyMapIdHashCode+
  293.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DENY_REQUEST_COUNTER+
  294.                     policyDate+
  295.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  296.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  297.             
  298.             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  299.                 this.distributedPolicyCounter = new DatoRAtomicLong(this.redisson,
  300.                         this.groupByPolicyMapIdHashCode+
  301.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_COUNTER+
  302.                         policyDate+
  303.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  304.                         (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  305.             }
  306.         }
  307.     }
  308.     
  309.     private void initPolicyCountersDegradoPrestazionale(Long policyDate) {
  310.         
  311.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  312.             this.distributedPolicyDegradoPrestazionaleCounter = new DatoRAtomicLong(this.redisson,
  313.                     this.groupByPolicyMapIdHashCode+BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_COUNTER+policyDate);
  314.             
  315.             this.distributedPolicyDegradoPrestazionaleRequestCounter = new DatoRAtomicLong(this.redisson,
  316.                     this.groupByPolicyMapIdHashCode+BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_REQUEST_COUNTER+policyDate);
  317.         }   
  318.         
  319.     }
  320.     
  321.     
  322.     @Override
  323.     protected void resetPolicyCounterForDate(Date date) {

  325.         if(this.initialized) {
  326.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDate");
  327.             try {
  328.                 long policyDate = date.getTime();
  329.                 long actual = this.distributedPolicyDate.get();
  330.                 long actualSuper = super.policyDate!=null ? super.policyDate.getTime() : -1;
  331.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDate.compareAndSet(actual, policyDate)) {                  
  332.                 
  333.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  334.                     // Potrà capitare che il cestino di un nodo non venga svuotato se si entra sempre sull'altro, cmq sia rimarrà 1 cestino con dei contatori di 1 intervallo.
  335.                     // Non appena ci entra poi li distruggerà.
  336.             
  337.                     // effettuo il drop creati due intervalli indietro
  338.                     if(!this.cestinoPolicyCounters.isEmpty()) {
  339.                         for (DatoRAtomicLong iAtomicLong : this.cestinoPolicyCounters) {
  340.                             iAtomicLong.delete();
  341.                         }
  342.                         this.cestinoPolicyCounters.clear();
  343.                     }
  344.                     
  345.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  346.                         // conservo precedenti contatori
  347.                         if(this.distributedPolicyRequestCounter!=null) {
  348.                             this.cestinoPolicyCounters.add(this.distributedPolicyRequestCounter);
  349.                         }
  350.                         if(this.distributedPolicyDenyRequestCounter!=null) {
  351.                             this.cestinoPolicyCounters.add(this.distributedPolicyDenyRequestCounter);
  352.                         }
  353.                         if(this.distributedPolicyCounter!=null) {
  354.                             this.cestinoPolicyCounters.add(this.distributedPolicyCounter);
  355.                         }
  356.                     }
  357.                                         
  358.                 }

  360.                 if(actualSuper!=policyDate) {
  361.                     
  362.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  363.                     initPolicyCounters(date.getTime());
  364.                     
  365.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  366.                     super.resetPolicyCounterForDate(date);
  367.                 }
  368.                 
  369.             }finally {
  370.                 this.lock.release(slock, "resetPolicyCounterForDate");
  371.             }
  372.         }
  373.         else {
  374.             super.resetPolicyCounterForDate(date);
  375.         }
  376.     }
  377.     
  378.     
  379.     @Override
  380.     protected void resetPolicyCounterForDateDegradoPrestazionale(Date date) {
  381.         
  382.         if(this.initialized) {
  383.             
  384.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDateDegradoPrestazionale");
  385.             try {
  386.                 long policyDate = date.getTime();
  387.                 long actual = this.distributedPolicyDate.get();
  388.                 long actualSuper = super.policyDegradoPrestazionaleDate!=null ? super.policyDegradoPrestazionaleDate.getTime() : -1;
  389.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(actual, policyDate)) {  
  390.                 
  391.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  392.                     // Potrà capitare che il cestino di un nodo non venga svuotato se si entra sempre sull'altro, cmq sia rimarrà 1 cestino con dei contatori di 1 intervallo.
  393.                     // Non appena ci entra poi li distruggerà.
  394.                     
  395.                     // effettuo il drop creati due intervalli indietro
  396.                     if(!this.cestinoPolicyCountersDegradoPrestazionale.isEmpty()) {
  397.                         for (DatoRAtomicLong iAtomicLong : this.cestinoPolicyCountersDegradoPrestazionale) {
  398.                             iAtomicLong.delete();
  399.                         }
  400.                         this.cestinoPolicyCountersDegradoPrestazionale.clear();
  401.                     }
  402.                     
  403.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  404.                         // conservo precedenti contatori
  405.                         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  406.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleCounter);
  407.                         }
  408.                         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  409.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleRequestCounter);
  410.                         }
  411.                     }
  412.                     
  413.                 }
  414.                 
  415.                 if(actualSuper!=policyDate) {
  416.                     
  417.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  418.                     initPolicyCountersDegradoPrestazionale(policyDate);
  419.                     
  420.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  421.                     super.resetPolicyCounterForDateDegradoPrestazionale(date);
  422.                 }
  423.                 
  424.             }finally {
  425.                 this.lock.release(slock, "resetPolicyCounterForDateDegradoPrestazionale");
  426.             }
  427.         }
  428.         else {
  429.             super.resetPolicyCounterForDateDegradoPrestazionale(date);
  430.         }
  431.     }
  432.     
  433.     
  434.     @Override
  435.     public void resetCounters(Date updatePolicyDate) {
  436.         super.resetCounters(updatePolicyDate);
  437.         
  438.         if(updatePolicyDate!=null) {
  439.             this.distributedUpdatePolicyDate.set(updatePolicyDate.getTime());
  440.         }
  441.         
  442.         if (this.distributedPolicyDenyRequestCounter != null) {
  443.             this.distributedPolicyDenyRequestCounter.set(0);
  444.         }
  445.         
  446.         if (this.distributedPolicyRequestCounter != null) {
  447.             this.distributedPolicyRequestCounter.set(0l);
  448.         }
  449.         
  450.         if (this.distributedPolicyCounter != null) {
  451.             this.distributedPolicyCounter.set(0l);
  452.         }

  454.         if (this.distributedPolicyDegradoPrestazionaleRequestCounter != null) {
  455.             this.distributedPolicyDegradoPrestazionaleRequestCounter.set(0l);
  456.         }
  457.         
  458.         if (this.distributedPolicyDegradoPrestazionaleCounter != null) {
  459.             this.distributedPolicyDegradoPrestazionaleCounter.set(0l);
  460.         }
  461.         
  462.     }

  464.     
  465.     @Override
  466.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  467.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  468.             if(datiCollezionatiPerPolicyVerifier!=null) {
  469.                 super.activeRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetActiveRequestCounter(this.distributedActiveRequestCounterForCheck.incrementAndGet());
  470.             }
  471.             else {
  472.                 super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.incrementAndGet();
  473.             }
  474.         }
  475.         else {
  476.             this.distributedActiveRequestCounterForStats.incrementAndGetAsync();
  477.         }
  478.     }
  479.     
  480.     
  481.     @Override
  482.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  483.         if(datiCollezionatiPerPolicyVerifier!=null) {
  484.             super.policyRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetPolicyRequestCounter(this.distributedPolicyRequestCounter.incrementAndGet());
  485.         }
  486.         else {
  487.             super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  488.         }
  489.     }
  490.     
  491.     
  492.     @Override
  493.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  494.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  495.             super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.decrementAndGet();
  496.         }
  497.         else {
  498.             this.distributedActiveRequestCounterForStats.decrementAndGetAsync();
  499.         }
  500.     }
  501.     @Override
  502.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  503.         super.policyDegradoPrestazionaleRequestCounter = this.distributedPolicyDegradoPrestazionaleRequestCounter.incrementAndGet();
  504.     }
  505.     @Override
  506.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  507.         super.policyDegradoPrestazionaleCounter = this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(latenza);
  508.     }
  509.     

  511.     
  512.     @Override
  513.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  514.         super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  515.     }
  516.     @Override
  517.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  518.         super.policyRequestCounter = this.distributedPolicyRequestCounter.decrementAndGet();
  519.     }
  520.     @Override
  521.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  522.         this.distributedPolicyDenyRequestCounter.incrementAndGetAsync();
  523.     }
  524.     @Override
  525.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  526.         super.policyCounter = this.distributedPolicyCounter.addAndGet(v);
  527.     }

  529.     
  530.     @Override
  531.     public void destroyDatiDistribuiti() {
  532.         if(this.distributedPolicyDate!=null) {
  533.             this.distributedPolicyDate.delete();
  534.         }
  535.         if(this.distributedUpdatePolicyDate!=null) {
  536.             this.distributedUpdatePolicyDate.delete();
  537.         }
  538.         
  539.         if(this.distributedPolicyRequestCounter!=null) {
  540.             this.distributedPolicyRequestCounter.delete();
  541.         }
  542.         if(this.distributedPolicyCounter!=null) {
  543.             this.distributedPolicyCounter.delete();
  544.         }
  545.         
  546.         if(this.distributedPolicyDegradoPrestazionaleDate!=null) {
  547.             this.distributedPolicyDegradoPrestazionaleDate.delete();
  548.         }
  549.         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  550.             this.distributedPolicyDegradoPrestazionaleRequestCounter.delete();
  551.         }
  552.         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  553.             this.distributedPolicyDegradoPrestazionaleCounter.delete();
  554.         }
  555.         
  556.         if(this.distributedActiveRequestCounterForStats!=null) {
  557.             this.distributedActiveRequestCounterForStats.delete();
  558.         }
  559.         if(this.distributedActiveRequestCounterForCheck!=null) {
  560.             this.distributedActiveRequestCounterForCheck.delete();
  561.         }
  562.         
  563.         if(this.distributedPolicyDenyRequestCounter!=null) {
  564.             this.distributedPolicyDenyRequestCounter.delete();
  565.         }
  566.     }
  567.     
  568.     
  569.     // Getters necessari poichè non viene aggiornato il field nella classe padre DatiCollezionati, poichè si usa il metodo Async nel caso di informazioni statistiche
  570.     
  571.     @Override
  572.     public Long getActiveRequestCounter(boolean readRemoteInfo) {
  573.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  574.             if(readRemoteInfo) {
  575.                 return this.distributedActiveRequestCounterForCheck.get();  
  576.             }
  577.             else {
  578.                 return super.activeRequestCounter; // nelle operazioni di incremento/decremento l'ho aggiarnato via via e quindi il check utilizzerà questa informazione nel PolicyVerifier
  579.             }
  580.         }
  581.         else {
  582.             return this.distributedActiveRequestCounterForStats.get();
  583.         }
  584.     }

  586.     
  587.     // Getters non necessari, sono utili solo se viene richiesta una lettura del dato remoto
  588.     
  589.     @Override
  590.     public Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  591.         if(readRemoteInfo) {
  592.             if(this.distributedPolicyDenyRequestCounter!=null) {
  593.                 return this.distributedPolicyDenyRequestCounter.get();
  594.             }
  595.             else {
  596.                 return null;
  597.             }
  598.         }
  599.         else {
  600.             return super.getPolicyDenyRequestCounter(readRemoteInfo);
  601.         }
  602.     }
  603.     
  604.     @Override
  605.     public Long getPolicyRequestCounter(boolean readRemoteInfo) {
  606.         if(readRemoteInfo) {
  607.             if(this.distributedPolicyRequestCounter!=null) {
  608.                 return this.distributedPolicyRequestCounter.get();
  609.             }
  610.             else {
  611.                 return null;
  612.             }
  613.         }
  614.         else {
  615.             return super.getPolicyRequestCounter(readRemoteInfo);
  616.         }
  617.     }
  618.     @Override
  619.     public Long getPolicyCounter(boolean readRemoteInfo) {
  620.         if(readRemoteInfo) {
  621.             if(this.distributedPolicyCounter!=null) {
  622.                 return this.distributedPolicyCounter.get();
  623.             }
  624.             else {
  625.                 return null;
  626.             }
  627.         }
  628.         else {
  629.             return super.getPolicyCounter(readRemoteInfo);
  630.         }
  631.     }   
  632.     
  633.     @Override
  634.     public Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  635.         if(readRemoteInfo) {
  636.             if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  637.                 return this.distributedPolicyDegradoPrestazionaleRequestCounter.get();
  638.             }
  639.             else {
  640.                 return null;
  641.             }
  642.         }
  643.         else {
  644.             return super.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  645.         }
  646.     }
  647.     @Override
  648.     public Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  649.         if(readRemoteInfo) {
  650.             if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  651.                 return this.distributedPolicyDegradoPrestazionaleCounter.get();
  652.             }
  653.             else {
  654.                 return null;
  655.             }
  656.         }
  657.         else {
  658.             return super.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  659.         }
  660.     }
  661. }
Created with JaCoCo 0.8.8.202204050719