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



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

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

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

  38. import com.hazelcast.core.HazelcastInstance;

  40. /**
  41.  * Scelgo questa implementazione, dove la versione distribuita eredita da DatiCollezionati e replica
  42.  * i dati da distribuitre.
  43.  * In questo modo, le varie PolicyGroupByActiveThreads* continueranno a restituire un oggetto di tipo DatiCollezionati. Con dati che sono presenti
  44.  * nella ram del nodo locale, evitando così che il PolicyVerifier o altre classi che utilizzano i DatiCollezionatiDistributed vadano 
  45.  * a fare richieste remote, ottenendo valori che non sono quelli che ci si aspettava dopo la richiesta.
  46.  * 
  47.  *  CP_SUBSYSTEM (https://docs.hazelcast.com/hazelcast/5.3/cp-subsystem/cp-subsystem)
  48.  *  Sottosistema hazelcast che garantisce consistenza e partizionamento per gli IAtomicLong e altri oggetti distribuiti (Non le MAP)
  49.  *  Richide almeno tre nodi nel cluster.
  50.  * - Strong Consistency: La vista dei dati è la stessa per tutti i nodi del cluster, garantida dal sistema CP
  51.  * - Weak Consistency: Dopo un certo lasso di tempo senza aggiornamenti, la vista dei dati diventa la stessa per tutti i nodi del cluster
  52.  * - Partitioning:
  53.  *      A partition is a communications break within a distributed system—a lost or temporarily delayed connection between two nodes.
  54.  *      Partition tolerance means that the cluster must continue to work despite any number of communication breakdowns between nodes in the system.    
  55.  * 
  56.  * @author Francesco Scarlato (scarlato@link.it)
  57.  * @author $Author$
  58.  * @version $Rev$, $Date$
  59.  */
  60. public class DatiCollezionatiDistributedAtomicLong extends DatiCollezionati implements IDatiCollezionatiDistributed{

  62.     private static final long serialVersionUID = 1L;
  63.     
  64.     private final transient org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("DatiCollezionatiDistributedAtomicLong");
  65.     
  66.     private final transient HazelcastInstance hazelcast;
  67.     private final IDUnivocoGroupByPolicyMapId groupByPolicyMapId;
  68.     private final int groupByPolicyMapIdHashCode;
  69.     
  70.     // data di registrazione/aggiornamento policy
  71.     
  72.     // final: sono i contatori che non dipendono da una finestra temporale
  73.     
  74.     protected final transient DatoAtomicLong distributedUpdatePolicyDate; // data di ultima modifica della policy
  75.     protected final transient DatoAtomicLong distributedPolicyDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  76.     
  77.     protected transient DatoAtomicLong distributedPolicyRequestCounter; // numero di richieste effettuato nell'intervallo
  78.     protected transient DatoAtomicLong distributedPolicyCounter; // utilizzato per tempi o banda
  79.     
  80.     protected final transient DatoAtomicLong distributedPolicyDegradoPrestazionaleDate; // intervallo corrente su cui vengono costruiti gli altri contatori
  81.     protected transient DatoAtomicLong distributedPolicyDegradoPrestazionaleRequestCounter; // numero di richieste effettuato nell'intervallo
  82.     protected transient DatoAtomicLong distributedPolicyDegradoPrestazionaleCounter; // contatore del degrado
  83.     
  84.     protected final transient boolean distribuitedActiveRequestCounterPolicyRichiesteSimultanee;
  85.     protected final transient DatoAtomicLong distributedActiveRequestCounterForStats; // numero di richieste simultanee
  86.     protected transient DatoAtomicLong distributedActiveRequestCounterForCheck; // numero di richieste simultanee
  87.     
  88.     protected transient DatoAtomicLong distributedPolicyDenyRequestCounter; // policy bloccate
  89.     
  90.     // I contatori da eliminare 
  91.     // 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'
  92.     // 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.
  93.     // per questo motivo, il drop viene effettuato al secondo cambio di intervallo, e ad ogni cambio i contatori vengono collezionati nel cestino
  94.     private transient List<DatoAtomicLong> cestinoPolicyCounters = new ArrayList<>();
  95.     private transient List<DatoAtomicLong> cestinoPolicyCountersDegradoPrestazionale = new ArrayList<>();
  96.         
  97.     private boolean initialized = false;

  99.     public DatiCollezionatiDistributedAtomicLong(Logger log, Date updatePolicyDate, Date gestorePolicyConfigDate, HazelcastInstance hazelcast, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  100.         super(updatePolicyDate, gestorePolicyConfigDate);
  101.     
  102.         this.hazelcast = hazelcast;
  103.         this.groupByPolicyMapId = groupByPolicyMapId;
  104.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  105.         
  106.         this.initDatiIniziali(activePolicy);
  107.         this.checkDate(log, activePolicy); // inizializza le date se ci sono
  108.         
  109.         this.distributedPolicyDate = this.initPolicyDate();
  110.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  111.         
  112.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();
  113.         
  114.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  115.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  116.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  117.             this.distributedActiveRequestCounterForCheck = initActiveRequestCounters();
  118.             this.distributedActiveRequestCounterForStats = null;
  119.         }
  120.         else {
  121.             this.distributedActiveRequestCounterForStats = initActiveRequestCounters();
  122.         }
  123.         
  124.         if(this.policyRealtime!=null && this.policyRealtime){
  125.             initPolicyCounters(super.getPolicyDate().getTime());
  126.         }
  127.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  128.             initPolicyCountersDegradoPrestazionale(super.getPolicyDegradoPrestazionaleDate().getTime());
  129.         }
  130.         
  131.         // Gestisco la updatePolicyDate qui, in questo modo risparmio un accesso in rete per ogni registerStartRequest.
  132.         // se updatePolicyDate è > this.distributedUpdatePolicyDate.get() allora resetto i contatori del cluster e setto la nuova data distribuita.
  133.         // Questo per via di come funziona l'aggiornamento delle policy: i datiCollezionati correnti per una map<IDUnivoco..., DatiCollezionati> vengono cancellati e reinizializzati.
  134.         // Per gli altri nodi in esecuzione, la updatePolicyDate locale resta sempre la stessa, ma non viene usata.
  135.         if(this.policyRealtime!=null && this.policyRealtime &&
  136.             updatePolicyDate != null && this.distributedUpdatePolicyDate!=null && this.distributedUpdatePolicyDate.get() < updatePolicyDate.getTime()) {
  137.             this.resetCounters(updatePolicyDate);
  138.         }
  139.         
  140.         this.initialized = true;
  141.     }
  142.         
  143.     public DatiCollezionatiDistributedAtomicLong(Logger log, DatiCollezionati dati, HazelcastInstance hazelcast, IDUnivocoGroupByPolicyMapId groupByPolicyMapId, ActivePolicy activePolicy) {
  144.         super(dati.getUpdatePolicyDate(), dati.getGestorePolicyConfigDate());
  145.         
  146.         if(log!=null) {
  147.             // nop
  148.         }
  149.         
  150.         // Inizializzo il padre con i valori in RAM, dopo uso 'super' per essere  sicuro di usare quelli
  151.         dati.setValuesIn(this, false);
  152.         
  153.         this.hazelcast = hazelcast;
  154.         this.groupByPolicyMapId = groupByPolicyMapId;
  155.         this.groupByPolicyMapIdHashCode = this.groupByPolicyMapId.hashCode();
  156.         
  157.         this.distributedPolicyDate = this.initPolicyDate();
  158.         this.distributedUpdatePolicyDate = this.initUpdatePolicyDate();
  159.         
  160.         this.distributedPolicyDegradoPrestazionaleDate = this.initPolicyDegradoPrestazionaleDate();
  161.         
  162.         this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee = activePolicy.getConfigurazionePolicy().isSimultanee() &&
  163.                 TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo());
  164.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  165.             this.distributedActiveRequestCounterForCheck = initActiveRequestCounters();
  166.             this.distributedActiveRequestCounterForStats = null;
  167.         }
  168.         else {
  169.             this.distributedActiveRequestCounterForStats = initActiveRequestCounters();
  170.         }
  171.         
  172.         
  173.         // Se non ho la policyDate, non considero il resto delle informazioni, che senza di essa non hanno senso.
  174.         if (super.getPolicyDate() != null) {

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

  253.     private DatoAtomicLong initPolicyDate() {
  254.         if(this.policyRealtime!=null && this.policyRealtime){
  255.             return new DatoAtomicLong(this.hazelcast, 
  256.                     this.groupByPolicyMapIdHashCode+
  257.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DATE+
  258.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  259.         }
  260.         return null;
  261.     }
  262.     private DatoAtomicLong initUpdatePolicyDate() {
  263.         if(this.policyRealtime!=null && this.policyRealtime){
  264.             return new DatoAtomicLong(this.hazelcast, 
  265.                     this.groupByPolicyMapIdHashCode+
  266.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_UPDATE_POLICY_DATE+
  267.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  268.         }
  269.         return null;
  270.     }
  271.     private DatoAtomicLong initPolicyDegradoPrestazionaleDate() {
  272.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  273.             return new DatoAtomicLong(this.hazelcast,
  274.                     this.groupByPolicyMapIdHashCode+
  275.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_POLICY_DEGRADO_PRESTAZIONALE_DATE+
  276.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  277.         }
  278.         return null;
  279.     }
  280.     
  281.     private DatoAtomicLong initActiveRequestCounters() {
  282.         return new DatoAtomicLong(this.hazelcast,
  283.                 this.groupByPolicyMapIdHashCode+
  284.                 BuilderDatiCollezionatiDistributed.DISTRUBUITED_ACTIVE_REQUEST_COUNTER+
  285.                 (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  286.     }
  287.     
  288.     private void initPolicyCounters(Long policyDate) {

  290.         if(this.policyRealtime!=null && this.policyRealtime){
  291.                         
  292.             this.distributedPolicyRequestCounter = new DatoAtomicLong(this.hazelcast, 
  293.                     this.groupByPolicyMapIdHashCode+
  294.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_REQUEST_COUNTER+
  295.                     policyDate+
  296.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  297.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  298.             /**System.out.println("INIT DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] cout-> ["+this.distributedPolicyRequestCounter.getName()+"]");*/
  299.             
  300.             this.distributedPolicyDenyRequestCounter = new DatoAtomicLong(this.hazelcast, 
  301.                     this.groupByPolicyMapIdHashCode+
  302.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DENY_REQUEST_COUNTER+
  303.                     policyDate+
  304.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  305.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  306.             /**System.out.println("INIT DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] cout-> ["+this.distributedPolicyDenyRequestCounter.getName()+"]");*/
  307.             
  308.             if(this.tipoRisorsa==null || !isRisorsaContaNumeroRichieste(this.tipoRisorsa)){
  309.                 this.distributedPolicyCounter = new DatoAtomicLong(this.hazelcast,
  310.                         this.groupByPolicyMapIdHashCode+
  311.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_COUNTER+
  312.                         policyDate+
  313.                         BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  314.                         (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  315.                 /**System.out.println("INIT DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] cout-> ["+this.distributedPolicyCounter.getName()+"]");*/
  316.             }
  317.         }
  318.     }
  319.     
  320.     private void initPolicyCountersDegradoPrestazionale(Long policyDate) {
  321.         
  322.         if(this.policyDegradoPrestazionaleRealtime!=null && this.policyDegradoPrestazionaleRealtime){
  323.             this.distributedPolicyDegradoPrestazionaleCounter = new DatoAtomicLong(this.hazelcast,
  324.                     this.groupByPolicyMapIdHashCode+
  325.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_COUNTER+
  326.                     policyDate+
  327.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  328.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  329.             
  330.             this.distributedPolicyDegradoPrestazionaleRequestCounter = new DatoAtomicLong(this.hazelcast,
  331.                     this.groupByPolicyMapIdHashCode+
  332.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_INTERVAL_POLICY_DEGRADO_PRESTAZIONALE_REQUEST_COUNTER+
  333.                     policyDate+
  334.                     BuilderDatiCollezionatiDistributed.DISTRUBUITED_SUFFIX_CONFIG_DATE+
  335.                     (this.gestorePolicyConfigDate!=null ? this.gestorePolicyConfigDate.getTime() : -1));
  336.         }   
  337.     }
  338.     

  340.     
  341.     @Override
  342.     protected void resetPolicyCounterForDate(Date date) {

  344.         if(this.initialized) {
  345.             
  346.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDate");
  347.             try {
  348.                 /**System.out.println("RESET");*/
  349.                 long policyDate = date.getTime();
  350.                 long actual = this.distributedPolicyDate.get();
  351.                 long actualSuper = super.policyDate!=null ? super.policyDate.getTime() : -1;
  352.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDate.compareAndSet(actual, policyDate)) {                  
  353.                 
  354.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  355.                     // 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.
  356.                     // Non appena ci entra poi li distruggerà.
  357.                     
  358.                     /**System.out.println("RESET ENTRO!");*/
  359.                     
  360.                     // effettuo il drop creati due intervalli indietro
  361.                     if(!this.cestinoPolicyCounters.isEmpty()) {
  362.                         for (DatoAtomicLong iAtomicLong : this.cestinoPolicyCounters) {
  363.                             /**System.out.println("DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] destroy ["+iAtomicLong.getName()+"]");*/
  364.                             iAtomicLong.destroy();
  365.                         }
  366.                         this.cestinoPolicyCounters.clear();
  367.                     }
  368.                     
  369.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  370.                         // conservo precedenti contatori
  371.                         if(this.distributedPolicyRequestCounter!=null) {
  372.                             this.cestinoPolicyCounters.add(this.distributedPolicyRequestCounter);
  373.                             /**System.out.println("SALVO IN CESTINO DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] c ["+this.distributedPolicyRequestCounter.getName()+"]");*/
  374.                         }
  375.                         if(this.distributedPolicyDenyRequestCounter!=null) {
  376.                             this.cestinoPolicyCounters.add(this.distributedPolicyDenyRequestCounter);
  377.                             /**System.out.println("SALVO IN CESTINO DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] c ["+this.distributedPolicyDenyRequestCounter.getName()+"]");*/
  378.                         }
  379.                         if(this.distributedPolicyCounter!=null) {
  380.                             this.cestinoPolicyCounters.add(this.distributedPolicyCounter);
  381.                             /**System.out.println("SALVO IN CESTINO DATA["+org.openspcoop2.utils.date.DateManager.getDate()+"]["+org.openspcoop2.utils.date.DateManager.getTimeMillis()+"] c ["+this.distributedPolicyCounter.getName()+"]");*/
  382.                         }
  383.                     }
  384.                                                             
  385.                 }
  386.                 
  387.                 if(actualSuper!=policyDate) {
  388.                     
  389.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  390.                     initPolicyCounters(policyDate);
  391.                     
  392.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  393.                     super.resetPolicyCounterForDate(date);
  394.                 }
  395.                 
  396.             }finally {
  397.                 this.lock.release(slock, "resetPolicyCounterForDate");
  398.             }
  399.             
  400.         }
  401.         else {
  402.             super.resetPolicyCounterForDate(date);
  403.         }
  404.     }
  405.     
  406.     
  407.     @Override
  408.     protected void resetPolicyCounterForDateDegradoPrestazionale(Date date) {
  409.         
  410.         if(this.initialized) {
  411.             
  412.             SemaphoreLock slock = this.lock.acquireThrowRuntime("resetPolicyCounterForDateDegradoPrestazionale");
  413.             try {
  414.                 long policyDate = date.getTime();
  415.                 long actual = this.distributedPolicyDegradoPrestazionaleDate.get();
  416.                 long actualSuper = super.policyDegradoPrestazionaleDate!=null ? super.policyDegradoPrestazionaleDate.getTime() : -1;
  417.                 if(actualSuper!=policyDate && actual<policyDate && this.distributedPolicyDegradoPrestazionaleDate.compareAndSet(actual, policyDate)) {  
  418.                 
  419.                     // Solo 1 nodo del cluster deve entrare in questo codice, altrimenti vengono fatti destroy più volte sullo stesso contatore
  420.                     // 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.
  421.                     // Non appena ci entra poi li distruggerà.
  422.                     
  423.                     // effettuo il drop creati due intervalli indietro
  424.                     if(!this.cestinoPolicyCountersDegradoPrestazionale.isEmpty()) {
  425.                         for (DatoAtomicLong iAtomicLong : this.cestinoPolicyCountersDegradoPrestazionale) {
  426.                             iAtomicLong.destroy();
  427.                         }
  428.                         this.cestinoPolicyCountersDegradoPrestazionale.clear();
  429.                     }
  430.                     
  431.                     if(this.distributedPolicyRequestCounter!=null || this.distributedPolicyDenyRequestCounter!=null || this.distributedPolicyCounter!=null) {
  432.                         // conservo precedenti contatori
  433.                         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  434.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleCounter);
  435.                         }
  436.                         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  437.                             this.cestinoPolicyCountersDegradoPrestazionale.add(this.distributedPolicyDegradoPrestazionaleRequestCounter);
  438.                         }
  439.                     }
  440.                                                             
  441.                 }
  442.                 
  443.                 if(actualSuper!=policyDate) {
  444.                     
  445.                     // Serve per inizializzare i nuovi riferimenti ai contatori
  446.                     initPolicyCountersDegradoPrestazionale(policyDate);
  447.                     
  448.                     // Serve per aggiornare la copia in ram del nodo in cui non si e' entrati nell'if precedente
  449.                     super.resetPolicyCounterForDateDegradoPrestazionale(date);
  450.                 }
  451.                 
  452.             }finally {
  453.                 this.lock.release(slock, "resetPolicyCounterForDateDegradoPrestazionale");
  454.             }   
  455.         }
  456.         else {
  457.             super.resetPolicyCounterForDateDegradoPrestazionale(date);
  458.         }
  459.     }
  460.     
  461.     
  462.     @Override
  463.     public void resetCounters(Date updatePolicyDate) {
  464.         super.resetCounters(updatePolicyDate);
  465.         
  466.         if(updatePolicyDate!=null) {
  467.             this.distributedUpdatePolicyDate.set(updatePolicyDate.getTime());
  468.         }
  469.         
  470.         if (this.distributedPolicyDenyRequestCounter != null) {
  471.             this.distributedPolicyDenyRequestCounter.set(0);
  472.         }
  473.         
  474.         if (this.distributedPolicyRequestCounter != null) {
  475.             this.distributedPolicyRequestCounter.set(0l);
  476.         }
  477.         
  478.         if (this.distributedPolicyCounter != null) {
  479.             this.distributedPolicyCounter.set(0l);
  480.         }

  482.         if (this.distributedPolicyDegradoPrestazionaleRequestCounter != null) {
  483.             this.distributedPolicyDegradoPrestazionaleRequestCounter.set(0l);
  484.         }
  485.         
  486.         if (this.distributedPolicyDegradoPrestazionaleCounter != null) {
  487.             this.distributedPolicyDegradoPrestazionaleCounter.set(0l);
  488.         }
  489.         
  490.     }

  492.     
  493.     @Override
  494.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  495.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  496.             if(datiCollezionatiPerPolicyVerifier!=null) {
  497.                 super.activeRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetActiveRequestCounter(this.distributedActiveRequestCounterForCheck.incrementAndGet());
  498.             }
  499.             else {
  500.                 super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.incrementAndGet();
  501.             }
  502.         }
  503.         else {
  504.             this.distributedActiveRequestCounterForStats.incrementAndGetAsync();
  505.         }
  506.     }

  508.     
  509.     @Override
  510.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  511.         if(datiCollezionatiPerPolicyVerifier!=null) {
  512.             super.policyRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetPolicyRequestCounter(this.distributedPolicyRequestCounter.incrementAndGet());
  513.         }
  514.         else {
  515.             super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  516.         }
  517.     }
  518.     
  519.     
  520.     @Override
  521.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  522.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  523.             super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.decrementAndGet();
  524.         }
  525.         else {
  526.             this.distributedActiveRequestCounterForStats.decrementAndGetAsync();
  527.         }
  528.     }
  529.     @Override
  530.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  531.         super.policyDegradoPrestazionaleRequestCounter = this.distributedPolicyDegradoPrestazionaleRequestCounter.incrementAndGet();
  532.     }
  533.     @Override
  534.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  535.         super.policyDegradoPrestazionaleCounter = this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(latenza);
  536.     }
  537.     

  539.     @Override
  540.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  541.         super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  542.     }
  543.     @Override
  544.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  545.         super.policyRequestCounter = this.distributedPolicyRequestCounter.decrementAndGet();
  546.     }
  547.     @Override
  548.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  549.         this.distributedPolicyDenyRequestCounter.incrementAndGetAsync();
  550.     }
  551.     @Override
  552.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  553.         super.policyCounter = this.distributedPolicyCounter.addAndGet(v);
  554.     }

  556.     
  557.     @Override
  558.     public void destroyDatiDistribuiti() {
  559.         if(this.distributedPolicyDate!=null) {
  560.             this.distributedPolicyDate.destroy();
  561.         }
  562.         if(this.distributedUpdatePolicyDate!=null) {
  563.             this.distributedUpdatePolicyDate.destroy();
  564.         }
  565.         
  566.         if(this.distributedPolicyRequestCounter!=null) {
  567.             this.distributedPolicyRequestCounter.destroy();
  568.         }
  569.         if(this.distributedPolicyCounter!=null) {
  570.             this.distributedPolicyCounter.destroy();
  571.         }
  572.         
  573.         if(this.distributedPolicyDegradoPrestazionaleDate!=null) {
  574.             this.distributedPolicyDegradoPrestazionaleDate.destroy();
  575.         }
  576.         if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  577.             this.distributedPolicyDegradoPrestazionaleRequestCounter.destroy();
  578.         }
  579.         if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  580.             this.distributedPolicyDegradoPrestazionaleCounter.destroy();
  581.         }
  582.         
  583.         if(this.distributedActiveRequestCounterForStats!=null) {
  584.             this.distributedActiveRequestCounterForStats.destroy();
  585.         }
  586.         if(this.distributedActiveRequestCounterForCheck!=null) {
  587.             this.distributedActiveRequestCounterForCheck.destroy();
  588.         }
  589.         
  590.         if(this.distributedPolicyDenyRequestCounter!=null) {
  591.             this.distributedPolicyDenyRequestCounter.destroy();
  592.         }
  593.     }
  594.     
  595.     
  596.     // Getters necessari poichè non viene aggiornato il field nella classe padre DatiCollezionati, poichè si usa il metodo Async nel caso di informazioni statistiche
  597.     
  598.     @Override
  599.     public Long getActiveRequestCounter(boolean readRemoteInfo) {
  600.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  601.             if(readRemoteInfo) {
  602.                 return this.distributedActiveRequestCounterForCheck.get();  
  603.             }
  604.             else {
  605.                 return super.activeRequestCounter; // nelle operazioni di incremento/decremento l'ho aggiarnato via via e quindi il check utilizzerà questa informazione nel PolicyVerifier
  606.             }
  607.         }
  608.         else {
  609.             return this.distributedActiveRequestCounterForStats.get();
  610.         }
  611.     }
  612.     
  613.     // Getters non necessari, sono utili solo se viene richiesta una lettura del dato remoto
  614.     
  615.     @Override
  616.     public Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  617.         if(readRemoteInfo) {
  618.             if(this.distributedPolicyDenyRequestCounter!=null) {
  619.                 return this.distributedPolicyDenyRequestCounter.get();
  620.             }
  621.             else {
  622.                 return null;
  623.             }
  624.         }
  625.         else {
  626.             return super.getPolicyDenyRequestCounter(readRemoteInfo);
  627.         }
  628.     }
  629.     
  630.     @Override
  631.     public Long getPolicyRequestCounter(boolean readRemoteInfo) {
  632.         if(readRemoteInfo) {
  633.             if(this.distributedPolicyRequestCounter!=null) {
  634.                 return this.distributedPolicyRequestCounter.get();
  635.             }
  636.             else {
  637.                 return null;
  638.             }
  639.         }
  640.         else {
  641.             return super.getPolicyRequestCounter(readRemoteInfo);
  642.         }
  643.     }
  644.     @Override
  645.     public Long getPolicyCounter(boolean readRemoteInfo) {
  646.         if(readRemoteInfo) {
  647.             if(this.distributedPolicyCounter!=null) {
  648.                 return this.distributedPolicyCounter.get();
  649.             }
  650.             else {
  651.                 return null;
  652.             }
  653.         }
  654.         else {
  655.             return super.getPolicyCounter(readRemoteInfo);
  656.         }
  657.     }   
  658.     
  659.     @Override
  660.     public Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  661.         if(readRemoteInfo) {
  662.             if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  663.                 return this.distributedPolicyDegradoPrestazionaleRequestCounter.get();
  664.             }
  665.             else {
  666.                 return null;
  667.             }
  668.         }
  669.         else {
  670.             return super.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  671.         }
  672.     }
  673.     @Override
  674.     public Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  675.         if(readRemoteInfo) {
  676.             if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  677.                 return this.distributedPolicyDegradoPrestazionaleCounter.get();
  678.             }
  679.             else {
  680.                 return null;
  681.             }
  682.         }
  683.         else {
  684.             return super.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  685.         }
  686.     }
  687.     
  688. }
Created with JaCoCo 0.8.8.202204050719