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;

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

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


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

  45.     private static final long serialVersionUID = 1L;
  46.    
  47.     private final transient org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("DatiCollezionatiDistributedRedisAtomicLong");
  48.    
  49.     private final transient RedissonClient redisson;
  50.     private final IDUnivocoGroupByPolicyMapId groupByPolicyMapId;
  51.     private final int groupByPolicyMapIdHashCode;

  52.     // data di registrazione/aggiornamento policy
  53.    
  54.     // final: sono i contatori che non dipendono da una finestra temporale
  55.    
  56.     // sono rimasti AtomicLong le date
  57.     private final transient DatoRAtomicLong distributedUpdatePolicyDate; // data di ultima modifica della policy
  58.     private final transient DatoRAtomicLong distributedPolicyDate; // intervallo corrente su cui vengono costruiti gli altri contatori

  59.     private transient DatoRAtomicLong distributedPolicyRequestCounter;  // numero di richieste effettuato nell'intervallo
  60.     private transient DatoRAtomicLong distributedPolicyCounter; // utilizzato per tempi o banda
  61.    
  62.     private final transient DatoRAtomicLong distributedPolicyDegradoPrestazionaleDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  63.     private transient  DatoRAtomicLong distributedPolicyDegradoPrestazionaleRequestCounter; // numero di richieste effettuato nell'intervallo
  64.     private transient DatoRAtomicLong distributedPolicyDegradoPrestazionaleCounter; // contatore del degrado

  65.     private final boolean distribuitedActiveRequestCounterPolicyRichiesteSimultanee;
  66.     private final transient DatoRAtomicLong distributedActiveRequestCounterForStats; // numero di richieste simultanee
  67.     private transient DatoRAtomicLong distributedActiveRequestCounterForCheck; // numero di richieste simultanee
  68.    
  69.     private transient DatoRAtomicLong distributedPolicyDenyRequestCounter; // policy bloccate
  70.    
  71.     // I contatori da eliminare
  72.     // 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'
  73.     // 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.
  74.     // per questo motivo, il drop viene effettuato al secondo cambio di intervallo, e ad ogni cambio i contatori vengono collezionati nel cestino
  75.     private transient List<DatoRAtomicLong> cestinoPolicyCounters = new ArrayList<>();
  76.     private transient List<DatoRAtomicLong> cestinoPolicyCountersDegradoPrestazionale = new ArrayList<>();
  77.    
  78.     private boolean initialized = false;

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

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

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

  228.         }
  229.        
  230.         this.initialized = true;
  231.     }
  232.    
  233.     private DatoRAtomicLong initPolicyDate() {
  234.         if(this.policyRealtime!=null && this.policyRealtime){
  235.             return new DatoRAtomicLong(this.redisson,
  236.                     this.groupByPolicyMapIdHashCode+
  237.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DATE+
  238.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  239.         }
  240.         return null;
  241.     }
  242.     private DatoRAtomicLong initUpdatePolicyDate() {
  243.         if(this.policyRealtime!=null && this.policyRealtime){
  244.             return new DatoRAtomicLong(this.redisson,
  245.                     this.groupByPolicyMapIdHashCode
  246.                     +BuilderDatiCollezionatiDistributed.DISTRUBUITED_UPDATE_POLICY_DATE+
  247.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  248.         }
  249.         return null;
  250.     }
  251.     private DatoRAtomicLong initPolicyDegradoPrestazionaleDate() {
  252.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  253.             return new DatoRAtomicLong(this.redisson,
  254.                     this.groupByPolicyMapIdHashCode+
  255.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DEGRADO_PRESTAZIONALE_DATE+
  256.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  257.         }
  258.         return null;
  259.     }
  260.    
  261.     private DatoRAtomicLong initActiveRequestCounters() {
  262.         return new DatoRAtomicLong(this.redisson,
  263.                 this.groupByPolicyMapIdHashCode+
  264.                 BuilderDatiCollezionatiDistributed.DISTRUBUITED_ACTIVE_REQUEST_COUNTER+
  265.                 (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  266.     }
  267.    
  268.     private void initPolicyCounters(Long policyDate) {

  269.         if(this.policyRealtime!=null && this.policyRealtime){
  270.                        
  271.             this.distributedPolicyRequestCounter = new DatoRAtomicLong(this.redisson,
  272.                     this.groupByPolicyMapIdHashCode+
  273.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_REQUEST_COUNTER+
  274.                     policyDate+
  275.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  276.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  277.            
  278.             this.distributedPolicyDenyRequestCounter = new DatoRAtomicLong(this.redisson,
  279.                     this.groupByPolicyMapIdHashCode+
  280.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DENY_REQUEST_COUNTER+
  281.                     policyDate+
  282.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  283.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  284.            
  285.             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  286.                 this.distributedPolicyCounter = new DatoRAtomicLong(this.redisson,
  287.                         this.groupByPolicyMapIdHashCode+
  288.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_COUNTER+
  289.                         policyDate+
  290.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  291.                         (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  292.             }
  293.         }
  294.     }
  295.    
  296.     private void initPolicyCountersDegradoPrestazionale(Long policyDate) {
  297.        
  298.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  299.             this.distributedPolicyDegradoPrestazionaleCounter = new DatoRAtomicLong(this.redisson,
  300.                     this.groupByPolicyMapIdHashCode+BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_COUNTER+policyDate);
  301.            
  302.             this.distributedPolicyDegradoPrestazionaleRequestCounter = new DatoRAtomicLong(this.redisson,
  303.                     this.groupByPolicyMapIdHashCode+BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_REQUEST_COUNTER+policyDate);
  304.         }  
  305.        
  306.     }
  307.    
  308.    
  309.     @Override
  310.     protected void resetPolicyCounterForDate(Date date) {

  311.         if(this.initialized) {
  312.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDate");
  313.             try {
  314.                 long policyDate = date.getTime();
  315.                 long actual = this.distributedPolicyDate.get();
  316.                 long actualSuper = super.policyDate!=null ? super.policyDate.getTime() : -1;
  317.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDate.compareAndSet(actual, policyDate)) {                  
  318.                
  319.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  320.                     // 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.
  321.                     // Non appena ci entra poi li distruggerà.
  322.            
  323.                     // effettuo il drop creati due intervalli indietro
  324.                     if(!this.cestinoPolicyCounters.isEmpty()) {
  325.                         for (DatoRAtomicLong iAtomicLong : this.cestinoPolicyCounters) {
  326.                             iAtomicLong.delete();
  327.                         }
  328.                         this.cestinoPolicyCounters.clear();
  329.                     }
  330.                    
  331.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  332.                         // conservo precedenti contatori
  333.                         if(this.distributedPolicyRequestCounter!=null) {
  334.                             this.cestinoPolicyCounters.add(this.distributedPolicyRequestCounter);
  335.                         }
  336.                         if(this.distributedPolicyDenyRequestCounter!=null) {
  337.                             this.cestinoPolicyCounters.add(this.distributedPolicyDenyRequestCounter);
  338.                         }
  339.                         if(this.distributedPolicyCounter!=null) {
  340.                             this.cestinoPolicyCounters.add(this.distributedPolicyCounter);
  341.                         }
  342.                     }
  343.                                        
  344.                 }

  345.                 if(actualSuper!=policyDate) {
  346.                    
  347.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  348.                     initPolicyCounters(date.getTime());
  349.                    
  350.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  351.                     super.resetPolicyCounterForDate(date);
  352.                 }
  353.                
  354.             }finally {
  355.                 this.lock.release(slock, "resetPolicyCounterForDate");
  356.             }
  357.         }
  358.         else {
  359.             super.resetPolicyCounterForDate(date);
  360.         }
  361.     }
  362.    
  363.    
  364.     @Override
  365.     protected void resetPolicyCounterForDateDegradoPrestazionale(Date date) {
  366.        
  367.         if(this.initialized) {
  368.            
  369.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDateDegradoPrestazionale");
  370.             try {
  371.                 long policyDate = date.getTime();
  372.                 long actual = this.distributedPolicyDate.get();
  373.                 long actualSuper = super.policyDegradoPrestazionaleDate!=null ? super.policyDegradoPrestazionaleDate.getTime() : -1;
  374.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(actual, policyDate)) {  
  375.                
  376.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  377.                     // 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.
  378.                     // Non appena ci entra poi li distruggerà.
  379.                    
  380.                     // effettuo il drop creati due intervalli indietro
  381.                     if(!this.cestinoPolicyCountersDegradoPrestazionale.isEmpty()) {
  382.                         for (DatoRAtomicLong iAtomicLong : this.cestinoPolicyCountersDegradoPrestazionale) {
  383.                             iAtomicLong.delete();
  384.                         }
  385.                         this.cestinoPolicyCountersDegradoPrestazionale.clear();
  386.                     }
  387.                    
  388.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  389.                         // conservo precedenti contatori
  390.                         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  391.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleCounter);
  392.                         }
  393.                         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  394.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleRequestCounter);
  395.                         }
  396.                     }
  397.                    
  398.                 }
  399.                
  400.                 if(actualSuper!=policyDate) {
  401.                    
  402.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  403.                     initPolicyCountersDegradoPrestazionale(policyDate);
  404.                    
  405.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  406.                     super.resetPolicyCounterForDateDegradoPrestazionale(date);
  407.                 }
  408.                
  409.             }finally {
  410.                 this.lock.release(slock, "resetPolicyCounterForDateDegradoPrestazionale");
  411.             }
  412.         }
  413.         else {
  414.             super.resetPolicyCounterForDateDegradoPrestazionale(date);
  415.         }
  416.     }
  417.    
  418.    
  419.     @Override
  420.     public void resetCounters(Date updatePolicyDate) {
  421.         super.resetCounters(updatePolicyDate);
  422.        
  423.         if(updatePolicyDate!=null) {
  424.             this.distributedUpdatePolicyDate.set(updatePolicyDate.getTime());
  425.         }
  426.        
  427.         if (this.distributedPolicyDenyRequestCounter != null) {
  428.             this.distributedPolicyDenyRequestCounter.set(0);
  429.         }
  430.        
  431.         if (this.distributedPolicyRequestCounter != null) {
  432.             this.distributedPolicyRequestCounter.set(0l);
  433.         }
  434.        
  435.         if (this.distributedPolicyCounter != null) {
  436.             this.distributedPolicyCounter.set(0l);
  437.         }

  438.         if (this.distributedPolicyDegradoPrestazionaleRequestCounter != null) {
  439.             this.distributedPolicyDegradoPrestazionaleRequestCounter.set(0l);
  440.         }
  441.        
  442.         if (this.distributedPolicyDegradoPrestazionaleCounter != null) {
  443.             this.distributedPolicyDegradoPrestazionaleCounter.set(0l);
  444.         }
  445.        
  446.     }

  447.    
  448.     @Override
  449.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  450.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  451.             if(datiCollezionatiPerPolicyVerifier!=null) {
  452.                 super.activeRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetActiveRequestCounter(this.distributedActiveRequestCounterForCheck.incrementAndGet());
  453.             }
  454.             else {
  455.                 super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.incrementAndGet();
  456.             }
  457.         }
  458.         else {
  459.             this.distributedActiveRequestCounterForStats.incrementAndGetAsync();
  460.         }
  461.     }
  462.    
  463.    
  464.     @Override
  465.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  466.         if(datiCollezionatiPerPolicyVerifier!=null) {
  467.             super.policyRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetPolicyRequestCounter(this.distributedPolicyRequestCounter.incrementAndGet());
  468.         }
  469.         else {
  470.             super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  471.         }
  472.     }
  473.    
  474.    
  475.     @Override
  476.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  477.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  478.             super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.decrementAndGet();
  479.         }
  480.         else {
  481.             this.distributedActiveRequestCounterForStats.decrementAndGetAsync();
  482.         }
  483.     }
  484.     @Override
  485.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  486.         super.policyDegradoPrestazionaleRequestCounter = this.distributedPolicyDegradoPrestazionaleRequestCounter.incrementAndGet();
  487.     }
  488.     @Override
  489.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  490.         super.policyDegradoPrestazionaleCounter = this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(latenza);
  491.     }
  492.    

  493.    
  494.     @Override
  495.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  496.         super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  497.     }
  498.     @Override
  499.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  500.         super.policyRequestCounter = this.distributedPolicyRequestCounter.decrementAndGet();
  501.     }
  502.     @Override
  503.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  504.         this.distributedPolicyDenyRequestCounter.incrementAndGetAsync();
  505.     }
  506.     @Override
  507.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  508.         super.policyCounter = this.distributedPolicyCounter.addAndGet(v);
  509.     }

  510.    
  511.     @Override
  512.     public void destroyDatiDistribuiti() {
  513.         if(this.distributedPolicyDate!=null) {
  514.             this.distributedPolicyDate.delete();
  515.         }
  516.         if(this.distributedUpdatePolicyDate!=null) {
  517.             this.distributedUpdatePolicyDate.delete();
  518.         }
  519.        
  520.         if(this.distributedPolicyRequestCounter!=null) {
  521.             this.distributedPolicyRequestCounter.delete();
  522.         }
  523.         if(this.distributedPolicyCounter!=null) {
  524.             this.distributedPolicyCounter.delete();
  525.         }
  526.        
  527.         if(this.distributedPolicyDegradoPrestazionaleDate!=null) {
  528.             this.distributedPolicyDegradoPrestazionaleDate.delete();
  529.         }
  530.         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  531.             this.distributedPolicyDegradoPrestazionaleRequestCounter.delete();
  532.         }
  533.         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  534.             this.distributedPolicyDegradoPrestazionaleCounter.delete();
  535.         }
  536.        
  537.         if(this.distributedActiveRequestCounterForStats!=null) {
  538.             this.distributedActiveRequestCounterForStats.delete();
  539.         }
  540.         if(this.distributedActiveRequestCounterForCheck!=null) {
  541.             this.distributedActiveRequestCounterForCheck.delete();
  542.         }
  543.        
  544.         if(this.distributedPolicyDenyRequestCounter!=null) {
  545.             this.distributedPolicyDenyRequestCounter.delete();
  546.         }
  547.     }
  548.    
  549.    
  550.     // Getters necessari poichè non viene aggiornato il field nella classe padre DatiCollezionati, poichè si usa il metodo Async nel caso di informazioni statistiche
  551.    
  552.     @Override
  553.     public Long getActiveRequestCounter(boolean readRemoteInfo) {
  554.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  555.             if(readRemoteInfo) {
  556.                 return this.distributedActiveRequestCounterForCheck.get();  
  557.             }
  558.             else {
  559.                 return super.activeRequestCounter; // nelle operazioni di incremento/decremento l'ho aggiarnato via via e quindi il check utilizzerà questa informazione nel PolicyVerifier
  560.             }
  561.         }
  562.         else {
  563.             return this.distributedActiveRequestCounterForStats.get();
  564.         }
  565.     }

  566.    
  567.     // Getters non necessari, sono utili solo se viene richiesta una lettura del dato remoto
  568.    
  569.     @Override
  570.     public Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  571.         if(readRemoteInfo) {
  572.             if(this.distributedPolicyDenyRequestCounter!=null) {
  573.                 return this.distributedPolicyDenyRequestCounter.get();
  574.             }
  575.             else {
  576.                 return null;
  577.             }
  578.         }
  579.         else {
  580.             return super.getPolicyDenyRequestCounter(readRemoteInfo);
  581.         }
  582.     }
  583.    
  584.     @Override
  585.     public Long getPolicyRequestCounter(boolean readRemoteInfo) {
  586.         if(readRemoteInfo) {
  587.             if(this.distributedPolicyRequestCounter!=null) {
  588.                 return this.distributedPolicyRequestCounter.get();
  589.             }
  590.             else {
  591.                 return null;
  592.             }
  593.         }
  594.         else {
  595.             return super.getPolicyRequestCounter(readRemoteInfo);
  596.         }
  597.     }
  598.     @Override
  599.     public Long getPolicyCounter(boolean readRemoteInfo) {
  600.         if(readRemoteInfo) {
  601.             if(this.distributedPolicyCounter!=null) {
  602.                 return this.distributedPolicyCounter.get();
  603.             }
  604.             else {
  605.                 return null;
  606.             }
  607.         }
  608.         else {
  609.             return super.getPolicyCounter(readRemoteInfo);
  610.         }
  611.     }  
  612.    
  613.     @Override
  614.     public Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  615.         if(readRemoteInfo) {
  616.             if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  617.                 return this.distributedPolicyDegradoPrestazionaleRequestCounter.get();
  618.             }
  619.             else {
  620.                 return null;
  621.             }
  622.         }
  623.         else {
  624.             return super.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  625.         }
  626.     }
  627.     @Override
  628.     public Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  629.         if(readRemoteInfo) {
  630.             if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  631.                 return this.distributedPolicyDegradoPrestazionaleCounter.get();
  632.             }
  633.             else {
  634.                 return null;
  635.             }
  636.         }
  637.         else {
  638.             return super.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  639.         }
  640.     }
  641. }