DatiCollezionatiDistributedPNCounter.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.  */


  22. package org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.counters;

  24. import java.util.ArrayList;
  25. import java.util.Date;
  26. import java.util.List;

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

  37. import com.hazelcast.core.HazelcastInstance;
  38. /**
  39.  *  Con il PNCounter accettiamo qualche tipo di inconsistenza ovvero:
  40.  *  
  41.  *  I valori dei contatori su di un nodo possono differire da quelle di un altro nodo perchè le notifiche sui contatori giunte ai due nodi fino al tempo T sono state diverse.
  42.  *  Dunque capita che lo stato locale non rifletta lo stato globale. 
  43.  *  I PNCounter garantiscono comunque che dopo un certo lasso di tempo il valore locale dei contatori converge al valore esatto per tutti i nodi, dalla documentazione infatti:
  44.  * 
  45.  *  The counter guarantees that whenever two members have received the same set of updates, possibly in a different order, their state is identical, and any conflicting updates are merged automatically. 
  46.  *  If no new updates are made to the shared state, all members that can communicate will eventually have the same data.
  47.  * 
  48.  *  The updates to the counter are applied locally when invoked on a CRDT replica.
  49.  * 
  50.  *  https://docs.hazelcast.com/hazelcast/5.3/data-structures/pn-counter
  51.  *
  52.  * Attenzione:  Nel caso si diminuisse il numero delle repliche per il PNCounter, che di default è a INTEGER.MAX_VALUE per cui ogni membro ha la sua replica, 
  53.  *  gli aggiornamenti potrebbero non raggiungere il membro che ha fatto partire la modifica, sollevando una ConsistencyLostException.
  54.  *  
  55.  * @author Francesco Scarlato (scarlato@link.it)
  56.  * @author $Author$
  57.  * @version $Rev$, $Date$
  58.  */
  59. public class DatiCollezionatiDistributedPNCounter extends DatiCollezionati implements IDatiCollezionatiDistributed {

  61.     private static final long serialVersionUID = 1L;
  62.     
  63.     private final transient org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("DatiCollezionatiDistributedPNCounter");
  64.     
  65.     private final transient HazelcastInstance hazelcast;
  66.     private final IDUnivocoGroupByPolicyMapId groupByPolicyMapId;
  67.     private final int groupByPolicyMapIdHashCode;

  69.     // data di registrazione/aggiornamento policy
  70.     
  71.     // final: sono i contatori che non dipendono da una finestra temporale
  72.     
  73.     // sono rimasti AtomicLong le date
  74.     
  75.     private final transient DatoAtomicLong distributedUpdatePolicyDate; // data di ultima modifica della policy
  76.     private final transient DatoAtomicLong distributedPolicyDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  77.     
  78.     private transient DatoPNCounter distributedPolicyRequestCounter; // numero di richieste effettuato nell'intervallo
  79.     private transient DatoPNCounter distributedPolicyCounter; // utilizzato per tempi o banda
  80.         
  81.     private final transient DatoAtomicLong distributedPolicyDegradoPrestazionaleDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  82.     private transient DatoPNCounter distributedPolicyDegradoPrestazionaleRequestCounter; // numero di richieste effettuato nell'intervallo
  83.     private transient DatoPNCounter distributedPolicyDegradoPrestazionaleCounter; // contatore del degrado
  84.     
  85.     private final boolean distribuitedActiveRequestCounterPolicyRichiesteSimultanee;
  86.     private final transient DatoPNCounter distributedActiveRequestCounterForStats; // numero di richieste simultanee
  87.     private transient DatoPNCounter distributedActiveRequestCounterForCheck; // numero di richieste simultanee
  88.     
  89.     private transient DatoPNCounter distributedPolicyDenyRequestCounter; // policy bloccate
  90.     
  91.     // I contatori da eliminare 
  92.     // 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'
  93.     // 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.
  94.     // per questo motivo, il drop viene effettuato al secondo cambio di intervallo, e ad ogni cambio i contatori vengono collezionati nel cestino
  95.     private transient List<DatoPNCounter> cestinoPolicyCounters = new ArrayList<>();
  96.     private transient List<DatoPNCounter> cestinoPolicyCountersDegradoPrestazionale = new ArrayList<>();
  97.     
  98.     private boolean initialized = false;

  100.     private String getPNCounterName(String name, Long date) {
  101.         String t = "";
  102.         if(date!=null) {
  103.             t = date + "";
  104.         }
  105.         
  106.         String configDate = BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  107.                 (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1);
  108.         
  109.         return "pncounter-"+this.groupByPolicyMapIdHashCode+"-"+name+t+configDate+"-rl"; // non modificare inizio e fine poichè configurato in hazelcast config
  110.     }
  111.     
  112.     public DatiCollezionatiDistributedPNCounter(Logger log, Date updatePolicyDate, Date gestorePolicyConfigDate, HazelcastInstance hazelcast, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  113.         super(updatePolicyDate, gestorePolicyConfigDate);
  114.     
  115.         this.hazelcast = hazelcast;
  116.         this.groupByPolicyMapId = groupByPolicyMapId;
  117.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  118.         
  119.         this.initDatiIniziali(activePolicy);
  120.         this.checkDate(log, activePolicy); // inizializza le date se ci sono
  121.         
  122.         this.distributedPolicyDate = this.initPolicyDate();
  123.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  124.         
  125.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();

  127.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  128.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  129.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  130.             this.distributedActiveRequestCounterForCheck = this.initActiveRequestCounters();
  131.             this.distributedActiveRequestCounterForStats = null;
  132.         }
  133.         else {
  134.             this.distributedActiveRequestCounterForStats = this.initActiveRequestCounters();
  135.         }
  136.         
  137.         if(this.policyRealtime!=null && this.policyRealtime){
  138.             initPolicyCounters(super.getPolicyDate().getTime());
  139.         }
  140.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  141.             initPolicyCountersDegradoPrestazionale(super.getPolicyDegradoPrestazionaleDate().getTime());
  142.         }
  143.         
  144.         // Gestisco la updatePolicyDate qui.
  145.         // se updatePolicyDate è > this.distributedUpdatePolicyDate.get() allora resetto i contatori del cluster e setto la nuova data distribuita.
  146.         // Questo per via di come funziona l'aggiornamento delle policy: i datiCollezionati correnti per una map<IDUnivoco..., DatiCollezionati> vengono cancellati e reinizializzati.
  147.         // Per gli altri nodi in esecuzione, la updatePolicyDate locale resta sempre la stessa, ma non viene usata.
  148.         if(this.policyRealtime!=null && this.policyRealtime &&
  149.             updatePolicyDate != null && this.distributedUpdatePolicyDate!=null && this.distributedUpdatePolicyDate.get() < updatePolicyDate.getTime()) {
  150.             this.resetCounters(updatePolicyDate);
  151.         }
  152.         
  153.         this.initialized = true;
  154.     }
  155.         
  156.     public DatiCollezionatiDistributedPNCounter(Logger log, DatiCollezionati dati, HazelcastInstance hazelcast, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  157.         super(dati.getUpdatePolicyDate(), dati.getGestorePolicyConfigDate());
  158.         
  159.         if(log!=null) {
  160.             // nop
  161.         }
  162.         
  163.         // Inizializzo il padre
  164.         dati.setValuesIn(this, false);
  165.         
  166.         this.hazelcast = hazelcast;
  167.         this.groupByPolicyMapId = groupByPolicyMapId;
  168.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  169.         
  170.         this.distributedPolicyDate = this.initPolicyDate();
  171.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  172.         
  173.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();
  174.         
  175.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  176.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  177.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  178.             this.distributedActiveRequestCounterForCheck = this.initActiveRequestCounters();
  179.             this.distributedActiveRequestCounterForStats = null;
  180.         }
  181.         else {
  182.             this.distributedActiveRequestCounterForStats = this.initActiveRequestCounters();
  183.         }
  184.         
  185.         
  186.         // Se non ho la policyDate, non considero il resto delle informazioni, che senza di essa non hanno senso.
  187.         if (super.getPolicyDate() != null) {

  189.             // Se ci sono altri nodi che stanno andando, la distributedPolicyDate DEVE essere != 0 
  190.             // Se la policyDate è a zero vuol dire che questo è il primo nodo del cluster che sta inizializzando la policy per mezzo di un backup e che su tutto il cluster
  191.             // non sono ancora transitate richieste.
  192.             if (this.distributedPolicyDate!=null && this.distributedPolicyDate.compareAndSet(0, super.getPolicyDate().getTime())) {
  193.                 // Se la data distribuita non era inizializzata e questo nodo l'ha settata, imposto i contatori come da immagine bin.
  194.                 //  Faccio la addAndGet, in quanto tutti valori positivi, non entriamo in conflitto con gli altri nodi che stanno effettuando lo startup nello stesso momento
  195.                 
  196.                 Long polDate = super.getPolicyDate().getTime();
  197.                 initPolicyCounters(polDate);
  198.                 
  199.                 Long getPolicyRequestCounter = super.getPolicyRequestCounter(true);
  200.                 if (getPolicyRequestCounter != null) {
  201.                     this.distributedPolicyRequestCounter.addAndGet(getPolicyRequestCounter);
  202.                 }
  203.                 
  204.                 Long getPolicyDenyRequestCounter = super.getPolicyDenyRequestCounter(true);
  205.                 if (getPolicyDenyRequestCounter != null) {
  206.                     this.distributedPolicyDenyRequestCounter.addAndGet(getPolicyDenyRequestCounter);
  207.                 }
  208.                 
  209.                 if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  210.                     Long getPolicyCounter = super.getPolicyCounter(true);
  211.                     if (getPolicyCounter != null) {
  212.                         this.distributedPolicyCounter.addAndGet(getPolicyCounter);
  213.                     }
  214.                 }
  215.                 
  216.                 Long getActiveRequestCounter = super.getActiveRequestCounter(true);
  217.                 if (getActiveRequestCounter!=null && getActiveRequestCounter != 0) {
  218.                     if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  219.                         this.distributedActiveRequestCounterForCheck.addAndGet(getActiveRequestCounter);
  220.                     }
  221.                     else {
  222.                         if(this.distributedActiveRequestCounterForStats!=null) {
  223.                             this.distributedActiveRequestCounterForStats.addAndGet(getActiveRequestCounter);
  224.                         }
  225.                     }
  226.                 }
  227.                                                 
  228.             } else {
  229.                 
  230.                 Long polDate = this.distributedPolicyDate!=null ? this.distributedPolicyDate.get() : null;
  231.                 initPolicyCounters(polDate);
  232.                 
  233.             }
  234.         }
  235.         
  236.         // Se non ho la policyDegradoPrestazionaleDate, non considero il resto delle informazioni, che senza di essa non hanno senso.
  237.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime &&
  238.             super.getPolicyDegradoPrestazionaleDate() != null) {
  239.                 
  240.             // Imposto i contatori distribuiti solo se nel frattempo non l'ha fatto un altro thread del cluster.
  241.             if (this.distributedPolicyDegradoPrestazionaleDate!=null && this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(0, super.getPolicyDegradoPrestazionaleDate().getTime())) {
  242.                 
  243.                 Long degradoPrestazionaleTime = super.getPolicyDegradoPrestazionaleDate().getTime();
  244.                 initPolicyCountersDegradoPrestazionale(degradoPrestazionaleTime);
  245.                 
  246.                 Long getPolicyDegradoPrestazionaleRequestCounter = super.getPolicyDegradoPrestazionaleRequestCounter(true);
  247.                 if (getPolicyDegradoPrestazionaleRequestCounter != null) {
  248.                     this.distributedPolicyDegradoPrestazionaleRequestCounter.addAndGet(getPolicyDegradoPrestazionaleRequestCounter);
  249.                 }
  250.                 
  251.                 Long getPolicyDegradoPrestazionaleCounter = super.getPolicyDegradoPrestazionaleCounter(true);
  252.                 if (getPolicyDegradoPrestazionaleCounter != null) {
  253.                     this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(getPolicyDegradoPrestazionaleCounter);
  254.                 }
  255.             }  else {
  256.                 
  257.                 Long degradoPrestazionaleTime = this.distributedPolicyDegradoPrestazionaleDate!=null ? this.distributedPolicyDegradoPrestazionaleDate.get() : null;
  258.                 initPolicyCountersDegradoPrestazionale(degradoPrestazionaleTime);
  259.                 
  260.             }
  261.         }
  262.         
  263.         this.initialized = true;
  264.     }
  265.     
  266.     private DatoAtomicLong initPolicyDate() {
  267.         if(this.policyRealtime!=null && this.policyRealtime){
  268.             return new DatoAtomicLong(this.hazelcast,
  269.                     this.groupByPolicyMapIdHashCode+
  270.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DATE+
  271.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  272.         }
  273.         return null;
  274.     }
  275.     private DatoAtomicLong initUpdatePolicyDate() {
  276.         if(this.policyRealtime!=null && this.policyRealtime){
  277.             return new DatoAtomicLong(this.hazelcast,
  278.                     this.groupByPolicyMapIdHashCode+
  279.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_UPDATE_POLICY_DATE+
  280.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  281.         }
  282.         return null;
  283.     }
  284.     private DatoAtomicLong initPolicyDegradoPrestazionaleDate() {
  285.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  286.             return new DatoAtomicLong(this.hazelcast,
  287.                     this.groupByPolicyMapIdHashCode+
  288.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DEGRADO_PRESTAZIONALE_DATE+
  289.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  290.         }
  291.         return null;
  292.     }
  293.     
  294.     private DatoPNCounter initActiveRequestCounters() {
  295.         return new DatoPNCounter(this.hazelcast,
  296.                 getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_ACTIVE_REQUEST_COUNTER,
  297.                         (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1)));
  298.     }
  299.     
  300.     private void initPolicyCounters(Long policyDate) {

  302.         if(this.policyRealtime!=null && this.policyRealtime){
  303.                         
  304.             this.distributedPolicyRequestCounter = new DatoPNCounter(this.hazelcast,
  305.                     this.getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_REQUEST_COUNTER,policyDate));
  306.             
  307.             this.distributedPolicyDenyRequestCounter = new DatoPNCounter(this.hazelcast,
  308.                     this.getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DENY_REQUEST_COUNTER,policyDate));
  309.             
  310.             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  311.                 this.distributedPolicyCounter = new DatoPNCounter(this.hazelcast,
  312.                         this.getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_COUNTER,policyDate));
  313.             }
  314.         }
  315.     }
  316.     
  317.     private void initPolicyCountersDegradoPrestazionale(Long policyDate) {
  318.         
  319.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  320.             this.distributedPolicyDegradoPrestazionaleCounter = new DatoPNCounter(this.hazelcast,
  321.                     this.getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_COUNTER,policyDate));

  323.             this.distributedPolicyDegradoPrestazionaleRequestCounter = new DatoPNCounter(this.hazelcast,
  324.                     this.getPNCounterName(BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_REQUEST_COUNTER,policyDate));

  326.         }   
  327.     }
  328.     

  330.     @Override
  331.     protected void resetPolicyCounterForDate(Date date) {
  332.         if(this.initialized) {
  333.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDate");
  334.             try {
  335.                 long policyDate = date.getTime();
  336.                 long actual = this.distributedPolicyDate.get();
  337.                 long actualSuper = super.policyDate!=null ? super.policyDate.getTime() : -1;
  338.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDate.compareAndSet(actual, policyDate)) {                  
  339.                 
  340.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  341.                     // 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.
  342.                     // Non appena ci entra poi li distruggerà.
  343.     
  344.                     // effettuo il drop creati due intervalli indietro
  345.                     if(!this.cestinoPolicyCounters.isEmpty()) {
  346.                         for (DatoPNCounter pnCounter : this.cestinoPolicyCounters) {
  347.                             pnCounter.destroy();
  348.                         }
  349.                         this.cestinoPolicyCounters.clear();
  350.                     }
  351.                     
  352.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  353.                         // conservo precedenti contatori
  354.                         if(this.distributedPolicyRequestCounter!=null) {
  355.                             this.cestinoPolicyCounters.add(this.distributedPolicyRequestCounter);
  356.                         }
  357.                         if(this.distributedPolicyDenyRequestCounter!=null) {
  358.                             this.cestinoPolicyCounters.add(this.distributedPolicyDenyRequestCounter);
  359.                         }
  360.                         if(this.distributedPolicyCounter!=null) {
  361.                             this.cestinoPolicyCounters.add(this.distributedPolicyCounter);
  362.                         }
  363.                     }
  364.                                                         
  365.                 }
  366.                 
  367.                 if(actualSuper!=policyDate) {
  368.                     
  369.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  370.                     initPolicyCounters(policyDate);
  371.                     
  372.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  373.                     super.resetPolicyCounterForDate(date);
  374.                 }
  375.                 
  376.             }finally {
  377.                 this.lock.release(slock, "resetPolicyCounterForDate");
  378.             }
  379.         }
  380.         else {
  381.             super.resetPolicyCounterForDate(date);
  382.         }
  383.     }
  384.     
  385.     
  386.     @Override
  387.     protected void resetPolicyCounterForDateDegradoPrestazionale(Date date) {
  388.         
  389.         if(this.initialized) {
  390.             
  391.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDateDegradoPrestazionale");
  392.             try {
  393.                 long policyDate = date.getTime();
  394.                 long actual = this.distributedPolicyDate.get();
  395.                 long actualSuper = super.policyDegradoPrestazionaleDate!=null ? super.policyDegradoPrestazionaleDate.getTime() : -1;
  396.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(actual, policyDate)) {  
  397.                 
  398.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  399.                     // 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.
  400.                     // Non appena ci entra poi li distruggerà.
  401.                     
  402.                     // effettuo il drop creati due intervalli indietro
  403.                     if(!this.cestinoPolicyCountersDegradoPrestazionale.isEmpty()) {
  404.                         for (DatoPNCounter pnCounter : this.cestinoPolicyCountersDegradoPrestazionale) {
  405.                             pnCounter.destroy();
  406.                         }
  407.                         this.cestinoPolicyCountersDegradoPrestazionale.clear();
  408.                     }
  409.                     
  410.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  411.                         // conservo precedenti contatori
  412.                         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  413.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleCounter);
  414.                         }
  415.                         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  416.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleRequestCounter);
  417.                         }
  418.                     }
  419.                                         
  420.                 }
  421.                 
  422.                 if(actualSuper!=policyDate) {
  423.                     
  424.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  425.                     initPolicyCountersDegradoPrestazionale(policyDate);
  426.                     
  427.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  428.                     super.resetPolicyCounterForDateDegradoPrestazionale(date);
  429.                 }
  430.                 
  431.             }finally {
  432.                 this.lock.release(slock, "resetPolicyCounterForDateDegradoPrestazionale");
  433.             }
  434.         }
  435.         else {
  436.             super.resetPolicyCounterForDateDegradoPrestazionale(date);
  437.         }
  438.     }
  439.     
  440.     @Override
  441.     public void resetCounters(Date updatePolicyDate) {
  442.         super.resetCounters(updatePolicyDate);
  443.         
  444.         if(updatePolicyDate!=null) {
  445.             this.distributedUpdatePolicyDate.set(updatePolicyDate.getTime());
  446.         }
  447.         
  448.         if (this.distributedPolicyDenyRequestCounter != null) {
  449.             this.distributedPolicyDenyRequestCounter.subtractAndGet(this.distributedPolicyDenyRequestCounter.get());
  450.         }
  451.         
  452.         if (this.distributedPolicyRequestCounter != null)  {
  453.             this.distributedPolicyRequestCounter.subtractAndGet(this.distributedPolicyRequestCounter.get());
  454.         }
  455.         
  456.         if (this.distributedPolicyCounter != null) {
  457.             this.distributedPolicyCounter.subtractAndGet(this.distributedPolicyCounter.get());
  458.         }
  459.         
  460.         if (this.distributedPolicyDegradoPrestazionaleRequestCounter != null) {
  461.                 this.distributedPolicyDegradoPrestazionaleRequestCounter.subtractAndGet(this.distributedPolicyDegradoPrestazionaleRequestCounter.get());
  462.         }
  463.         
  464.         if (this.distributedPolicyDegradoPrestazionaleCounter != null) {
  465.             this.distributedPolicyDegradoPrestazionaleCounter.subtractAndGet(this.distributedPolicyDegradoPrestazionaleCounter.get());
  466.         }
  467.         
  468.     }
  469.     
  470.     
  471.     
  472.     @Override
  473.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  474.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  475.             if(datiCollezionatiPerPolicyVerifier!=null) {
  476.                 super.activeRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetActiveRequestCounter(this.distributedActiveRequestCounterForCheck.incrementAndGet());
  477.             }
  478.             else {
  479.                 super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.incrementAndGet();
  480.             }
  481.         }
  482.         else {
  483.             super.activeRequestCounter = this.distributedActiveRequestCounterForStats.incrementAndGet();
  484.         }
  485.     }
  486.     
  487.     
  488.     @Override
  489.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  490.         if(datiCollezionatiPerPolicyVerifier!=null) {
  491.             super.policyRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetPolicyRequestCounter(this.distributedPolicyRequestCounter.incrementAndGet());
  492.         }
  493.         else {
  494.             super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  495.         }
  496.     }
  497.     
  498.     
  499.     
  500.     @Override
  501.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  502.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  503.             super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.decrementAndGet();
  504.         }
  505.         else {
  506.             super.activeRequestCounter = this.distributedActiveRequestCounterForStats.decrementAndGet();
  507.         }
  508.     }
  509.     @Override
  510.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  511.         super.policyDegradoPrestazionaleRequestCounter = this.distributedPolicyDegradoPrestazionaleRequestCounter.incrementAndGet();
  512.     }
  513.     @Override
  514.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  515.         super.policyDegradoPrestazionaleCounter = this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(latenza);
  516.     }
  517.     
  518.     
  519.     @Override
  520.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  521.         super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  522.     }
  523.     @Override
  524.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  525.         super.policyRequestCounter = this.distributedPolicyRequestCounter.decrementAndGet();
  526.     }
  527.     @Override
  528.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  529.         super.policyDenyRequestCounter = this.distributedPolicyDenyRequestCounter.incrementAndGet();
  530.     }
  531.     @Override
  532.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  533.         super.policyCounter = this.distributedPolicyCounter.addAndGet(v);
  534.     }
  535.     
  536.     
  537.     
  538.     @Override
  539.     public void destroyDatiDistribuiti() {
  540.         if(this.distributedPolicyDate!=null) {
  541.             this.distributedPolicyDate.destroy();
  542.         }
  543.         if(this.distributedUpdatePolicyDate!=null) {
  544.             this.distributedUpdatePolicyDate.destroy();
  545.         }
  546.         
  547.         if(this.distributedPolicyRequestCounter!=null) {
  548.             this.distributedPolicyRequestCounter.destroy();
  549.         }
  550.         if(this.distributedPolicyCounter!=null) {
  551.             this.distributedPolicyCounter.destroy();
  552.         }
  553.         
  554.         if(this.distributedPolicyDegradoPrestazionaleDate!=null) {
  555.             this.distributedPolicyDegradoPrestazionaleDate.destroy();
  556.         }
  557.         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  558.             this.distributedPolicyDegradoPrestazionaleRequestCounter.destroy();
  559.         }
  560.         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  561.             this.distributedPolicyDegradoPrestazionaleCounter.destroy();
  562.         }
  563.         
  564.         if(this.distributedActiveRequestCounterForStats!=null) {
  565.             this.distributedActiveRequestCounterForStats.destroy();
  566.         }
  567.         if(this.distributedActiveRequestCounterForCheck!=null) {
  568.             this.distributedActiveRequestCounterForCheck.destroy();
  569.         }
  570.         
  571.         if(this.distributedPolicyDenyRequestCounter!=null) {
  572.             this.distributedPolicyDenyRequestCounter.destroy();
  573.         }
  574.     }
  575.     
  576.     
  577.     
  578.     // Getters non necessari, sono utili solo se viene richiesta una lettura del dato remoto
  579.     
  580.     @Override
  581.     public Long getActiveRequestCounter(boolean readRemoteInfo) {
  582.         if(readRemoteInfo) {
  583.             if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  584.                 return this.distributedActiveRequestCounterForCheck.get();  
  585.             }
  586.             else {
  587.                 return this.distributedActiveRequestCounterForStats.get();
  588.             }
  589.         }
  590.         else {
  591.             return super.getActiveRequestCounter(readRemoteInfo);
  592.         }
  593.     }
  594.         
  595.     @Override
  596.     public Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  597.         if(readRemoteInfo) {
  598.             if(this.distributedPolicyDenyRequestCounter!=null) {
  599.                 return this.distributedPolicyDenyRequestCounter.get();
  600.             }
  601.             else {
  602.                 return null;
  603.             }
  604.         }
  605.         else {
  606.             return super.getPolicyDenyRequestCounter(readRemoteInfo);
  607.         }
  608.     }
  609.     
  610.     @Override
  611.     public Long getPolicyRequestCounter(boolean readRemoteInfo) {
  612.         if(readRemoteInfo) {
  613.             if(this.distributedPolicyRequestCounter!=null) {
  614.                 return this.distributedPolicyRequestCounter.get();
  615.             }
  616.             else {
  617.                 return null;
  618.             }
  619.         }
  620.         else {
  621.             return super.getPolicyRequestCounter(readRemoteInfo);
  622.         }
  623.     }
  624.     @Override
  625.     public Long getPolicyCounter(boolean readRemoteInfo) {
  626.         if(readRemoteInfo) {
  627.             if(this.distributedPolicyCounter!=null) {
  628.                 return this.distributedPolicyCounter.get();
  629.             }
  630.             else {
  631.                 return null;
  632.             }
  633.         }
  634.         else {
  635.             return super.getPolicyCounter(readRemoteInfo);
  636.         }
  637.     }   
  638.     
  639.     @Override
  640.     public Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  641.         if(readRemoteInfo) {
  642.             if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  643.                 return this.distributedPolicyDegradoPrestazionaleRequestCounter.get();
  644.             }
  645.             else {
  646.                 return null;
  647.             }
  648.         }
  649.         else {
  650.             return super.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  651.         }
  652.     }
  653.     @Override
  654.     public Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  655.         if(readRemoteInfo) {
  656.             if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  657.                 return this.distributedPolicyDegradoPrestazionaleCounter.get();
  658.             }
  659.             else {
  660.                 return null;
  661.             }
  662.         }
  663.         else {
  664.             return super.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  665.         }
  666.     }
  667. }
Created with JaCoCo 0.8.8.202204050719