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



  20. package org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.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.slf4j.Logger;

  32. import com.hazelcast.core.HazelcastInstance;

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

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

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

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

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

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

  327.    
  328.     @Override
  329.     protected void resetPolicyCounterForDate(Date date) {

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

  467.         if (this.distributedPolicyDegradoPrestazionaleRequestCounter != null) {
  468.             this.distributedPolicyDegradoPrestazionaleRequestCounter.set(0l);
  469.         }
  470.        
  471.         if (this.distributedPolicyDegradoPrestazionaleCounter != null) {
  472.             this.distributedPolicyDegradoPrestazionaleCounter.set(0l);
  473.         }
  474.        
  475.     }

  476.    
  477.     @Override
  478.     protected void internalRegisterStartRequestIncrementActiveRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  479.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  480.             if(datiCollezionatiPerPolicyVerifier!=null) {
  481.                 super.activeRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetActiveRequestCounter(this.distributedActiveRequestCounterForCheck.incrementAndGet());
  482.             }
  483.             else {
  484.                 super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.incrementAndGet();
  485.             }
  486.         }
  487.         else {
  488.             this.distributedActiveRequestCounterForStats.incrementAndGetAsync();
  489.         }
  490.     }

  491.    
  492.     @Override
  493.     protected void internalUpdateDatiStartRequestApplicabileIncrementRequestCounter(DatiCollezionati datiCollezionatiPerPolicyVerifier) {
  494.         if(datiCollezionatiPerPolicyVerifier!=null) {
  495.             super.policyRequestCounter = datiCollezionatiPerPolicyVerifier.setAndGetPolicyRequestCounter(this.distributedPolicyRequestCounter.incrementAndGet());
  496.         }
  497.         else {
  498.             super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  499.         }
  500.     }
  501.    
  502.    
  503.     @Override
  504.     protected void internalRegisterEndRequestDecrementActiveRequestCounter() {
  505.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  506.             super.activeRequestCounter = this.distributedActiveRequestCounterForCheck.decrementAndGet();
  507.         }
  508.         else {
  509.             this.distributedActiveRequestCounterForStats.decrementAndGetAsync();
  510.         }
  511.     }
  512.     @Override
  513.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleRequestCounter() {
  514.         super.policyDegradoPrestazionaleRequestCounter = this.distributedPolicyDegradoPrestazionaleRequestCounter.incrementAndGet();
  515.     }
  516.     @Override
  517.     protected void internalRegisterEndRequestIncrementDegradoPrestazionaleCounter(long latenza) {
  518.         super.policyDegradoPrestazionaleCounter = this.distributedPolicyDegradoPrestazionaleCounter.addAndGet(latenza);
  519.     }
  520.    

  521.     @Override
  522.     protected void internalUpdateDatiEndRequestApplicabileIncrementRequestCounter() {
  523.         super.policyRequestCounter = this.distributedPolicyRequestCounter.incrementAndGet();
  524.     }
  525.     @Override
  526.     protected void internalUpdateDatiEndRequestApplicabileDecrementRequestCounter() {
  527.         super.policyRequestCounter = this.distributedPolicyRequestCounter.decrementAndGet();
  528.     }
  529.     @Override
  530.     protected void internalUpdateDatiEndRequestApplicabileIncrementDenyRequestCounter() {
  531.         this.distributedPolicyDenyRequestCounter.incrementAndGetAsync();
  532.     }
  533.     @Override
  534.     protected void internalUpdateDatiEndRequestApplicabileIncrementCounter(long v) {
  535.         super.policyCounter = this.distributedPolicyCounter.addAndGet(v);
  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.     // Getters necessari poichè non viene aggiornato il field nella classe padre DatiCollezionati, poichè si usa il metodo Async nel caso di informazioni statistiche
  578.    
  579.     @Override
  580.     public Long getActiveRequestCounter(boolean readRemoteInfo) {
  581.         if(this.distribuitedActiveRequestCounterPolicyRichiesteSimultanee){
  582.             if(readRemoteInfo) {
  583.                 return this.distributedActiveRequestCounterForCheck.get();  
  584.             }
  585.             else {
  586.                 return super.activeRequestCounter; // nelle operazioni di incremento/decremento l'ho aggiarnato via via e quindi il check utilizzerà questa informazione nel PolicyVerifier
  587.             }
  588.         }
  589.         else {
  590.             return this.distributedActiveRequestCounterForStats.get();
  591.         }
  592.     }
  593.    
  594.     // Getters non necessari, sono utili solo se viene richiesta una lettura del dato remoto
  595.    
  596.     @Override
  597.     public Long getPolicyDenyRequestCounter(boolean readRemoteInfo) {
  598.         if(readRemoteInfo) {
  599.             if(this.distributedPolicyDenyRequestCounter!=null) {
  600.                 return this.distributedPolicyDenyRequestCounter.get();
  601.             }
  602.             else {
  603.                 return null;
  604.             }
  605.         }
  606.         else {
  607.             return super.getPolicyDenyRequestCounter(readRemoteInfo);
  608.         }
  609.     }
  610.    
  611.     @Override
  612.     public Long getPolicyRequestCounter(boolean readRemoteInfo) {
  613.         if(readRemoteInfo) {
  614.             if(this.distributedPolicyRequestCounter!=null) {
  615.                 return this.distributedPolicyRequestCounter.get();
  616.             }
  617.             else {
  618.                 return null;
  619.             }
  620.         }
  621.         else {
  622.             return super.getPolicyRequestCounter(readRemoteInfo);
  623.         }
  624.     }
  625.     @Override
  626.     public Long getPolicyCounter(boolean readRemoteInfo) {
  627.         if(readRemoteInfo) {
  628.             if(this.distributedPolicyCounter!=null) {
  629.                 return this.distributedPolicyCounter.get();
  630.             }
  631.             else {
  632.                 return null;
  633.             }
  634.         }
  635.         else {
  636.             return super.getPolicyCounter(readRemoteInfo);
  637.         }
  638.     }  
  639.    
  640.     @Override
  641.     public Long getPolicyDegradoPrestazionaleRequestCounter(boolean readRemoteInfo) {
  642.         if(readRemoteInfo) {
  643.             if(this.distributedPolicyDegradoPrestazionaleRequestCounter!=null) {
  644.                 return this.distributedPolicyDegradoPrestazionaleRequestCounter.get();
  645.             }
  646.             else {
  647.                 return null;
  648.             }
  649.         }
  650.         else {
  651.             return super.getPolicyDegradoPrestazionaleRequestCounter(readRemoteInfo);
  652.         }
  653.     }
  654.     @Override
  655.     public Long getPolicyDegradoPrestazionaleCounter(boolean readRemoteInfo) {
  656.         if(readRemoteInfo) {
  657.             if(this.distributedPolicyDegradoPrestazionaleCounter!=null) {
  658.                 return this.distributedPolicyDegradoPrestazionaleCounter.get();
  659.             }
  660.             else {
  661.                 return null;
  662.             }
  663.         }
  664.         else {
  665.             return super.getPolicyDegradoPrestazionaleCounter(readRemoteInfo);
  666.         }
  667.     }
  668.    
  669. }