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

  21. package org.openspcoop2.pdd.core.controllo_traffico;

  23. import java.util.Date;

  25. import org.openspcoop2.core.commons.CoreException;
  26. import org.openspcoop2.core.constants.Costanti;
  27. import org.openspcoop2.core.controllo_traffico.constants.TipoErrore;
  28. import org.openspcoop2.message.constants.ServiceBinding;
  29. import org.openspcoop2.pdd.core.PdDContext;
  30. import org.openspcoop2.pdd.core.handlers.HandlerException;
  31. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  32. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  33. import org.openspcoop2.utils.SemaphoreLock;
  34. import org.openspcoop2.utils.date.DateManager;
  35. import org.slf4j.Logger;

  37. /**     
  38.  * GestoreControlloTraffico
  39.  *
  40.  * @author Poli Andrea (poli@link.it)
  41.  * @author $Author$
  42.  * @version $Rev$, $Date$
  43.  */
  44. public class GestoreControlloTraffico {
  45.     
  46.     private static GestoreControlloTraffico staticInstance = null;
  47.     public static synchronized void initialize(boolean erroreGenerico){
  48.         if(staticInstance==null){
  49.             staticInstance = new GestoreControlloTraffico(erroreGenerico);
  50.         }
  51.     }
  52.     public static GestoreControlloTraffico getInstance() throws CoreException{
  53.         if(staticInstance==null){
  54.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  55.             synchronized (GestoreControlloTraffico.class) {
  56.                 throw new CoreException("GestorePolicyAttive non inizializzato");
  57.             }
  58.         }
  59.         return staticInstance;
  60.     }
  61.     
  62.     
  63.     private GestoreControlloTraffico(boolean erroreGenerico){
  64.         this.erroreGenerico = erroreGenerico;
  65.     }
  66.     
  67.     /** 
  68.      * Threads attivi complessivi sulla Porta
  69.      **/
  70.     //private final Boolean semaphore = true; // Serve perche' senno cambiando i valori usando auto-box un-box, si perde il riferimento.
  71.     private final org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("GestoreControlloTraffico");
  72.     private long activeThreads = 0l;
  73.     private boolean pddCongestionata = false;
  74.     private boolean erroreGenerico;
  75.     public StatoTraffico getStatoControlloTraffico(String idTransazione, boolean sync) {
  76.         if(sync) {
  77.             long syncActiveThreads = 0l;
  78.             boolean syncPddCongestionata = false;
  79.             //synchronized (this.semaphore) {
  80.             SemaphoreLock lock = this.lock.acquireThrowRuntime("getStatoControlloTraffico", idTransazione);
  81.             try {
  82.                 syncActiveThreads = this.activeThreads;
  83.                 syncPddCongestionata = this.pddCongestionata;
  84.             }finally {
  85.                 this.lock.release(lock, "getStatoControlloTraffico", idTransazione);
  86.             }
  87.             StatoTraffico stato = new StatoTraffico();
  88.             stato.setActiveThreads(syncActiveThreads);
  89.             stato.setPddCongestionata(syncPddCongestionata);
  90.             return stato;
  91.         }
  92.         else {
  93.             //Risolve problema di deadlock che scaturiva utilizzando solamente 1 connessione e facendo un test in cui più thread invocavano con più messaggi, senza avere alcuna informazione in cache
  94.             // Si perde un pochino in precisione, ma risolve il problema del deadlock
  95.             StatoTraffico stato = new StatoTraffico();
  96.             stato.setActiveThreads(this.activeThreads);
  97.             stato.setPddCongestionata(this.pddCongestionata);
  98.             return stato;
  99.         }
  100.     }
  101.     public void addThread(ServiceBinding serviceBinding, Long maxThreadsObj, Integer thresholdObj, Boolean warningOnly, PdDContext pddContext, MsgDiagnostico msgDiag, 
  102.             TipoErrore tipoErrore, boolean includiDescrizioneErrore,Logger log) throws Exception{
  103.         
  104.         boolean emettiDiagnosticoMaxThreadRaggiunto = false;
  105.         
  106.         boolean emettiEventoMaxThreadsViolated = false;
  107.         String descriptionEventoMaxThreadsViolated = null;
  108.         Date dataEventoMaxThreadsViolated = null;
  109.         
  110.         boolean emettiEventoPddCongestionata = false;
  111.         String descriptionEventoPddCongestionata = null;
  112.         Date dataEventoPddCongestionata = null;
  113.         
  114.         try{
  115.             long maxThreadsPrimitive = maxThreadsObj.longValue();
  116.             int thresholdPrimitive = (thresholdObj!=null ? thresholdObj.intValue() : 0);
  117.             String idTransazione = (pddContext!=null && pddContext.containsKey(Costanti.ID_TRANSAZIONE)) ? PdDContext.getValue(Costanti.ID_TRANSAZIONE, pddContext) : null;
  118.             
  119.             long activeThreadsSyncBeforeIncrement = -1;
  120.             boolean errorSync = false;
  121.             boolean pddCongestionataSync = false; 
  122.             
  123.             //synchronized (this.semaphore) {
  124.             SemaphoreLock lock = this.lock.acquire("addThread", idTransazione);
  125.             try {
  126.                 activeThreadsSyncBeforeIncrement = this.activeThreads;
  127.                 //System.out.println("@@@addThread CONTROLLO ["+this.activeThreads+"]<["+maxThreads+"] ("+(!(this.activeThreads<maxThreads))+")");
  128.                 if(!(this.activeThreads<maxThreadsPrimitive)){
  129.                     errorSync = true;
  130.                 }
  131.                 if(!errorSync || warningOnly) {
  132.                     
  133.                     this.activeThreads++;
  134.                     
  135.                     if(thresholdObj!=null){
  136.                         pddCongestionataSync = this._isPddCongestionata(maxThreadsPrimitive, thresholdPrimitive); 
  137.                         
  138.                         //System.out.println("ACTIVE THREADS TOTALI: "+this.activeThreads);
  139.                         //System.out.println("PDD CONGESTIONATA: "+pddCongestionata);
  140.                         
  141.                         // verifica rispetto a variabile interna
  142.                         if(this.pddCongestionata){
  143.                             if(pddCongestionataSync==false){
  144.                                 //System.out.println("@@ NON PIU' RICHIESTO");
  145.                                 this.pddCongestionata = false;
  146.                             }
  147.                         }
  148.                         else{
  149.                             if(pddCongestionataSync){
  150.                                 //System.out.println("@@ C.T. RICHIESTO ATTIVO");
  151.                                 this.pddCongestionata = true;
  152.                                 
  153.                                 // Emetto un evento di congestione in corso
  154.                                 emettiEventoPddCongestionata = true;
  155.                                 dataEventoPddCongestionata = DateManager.getDate();
  156.                             }
  157.                         }
  158.                     }
  159.                 }
  160.                 //System.out.println("@@@addThread (dopo): "+this.activeThreads);
  161.             }finally {
  162.                 this.lock.release(lock, "addThread", idTransazione);
  163.             }
  164.             
  165.             HandlerException he = null;
  166.             if(errorSync) {
  167.                 emettiDiagnosticoMaxThreadRaggiunto = true;
  168.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_ACTIVE_THREADS, activeThreadsSyncBeforeIncrement+"");
  169.                 if(pddContext!=null) {
  170.                     pddContext.addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_ACTIVE_THREADS, activeThreadsSyncBeforeIncrement);
  171.                 }
  172.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_MAX_THREADS_THRESHOLD, maxThreadsPrimitive+"");
  173.                 
  174.                 //System.out.println("@@@addThread ERR");
  175.                 emettiEventoMaxThreadsViolated = true;
  176.                 descriptionEventoMaxThreadsViolated = "Superato il numero di richieste complessive ("+maxThreadsPrimitive+") gestibili dalla PdD";
  177.                 dataEventoMaxThreadsViolated = DateManager.getDate();
  178.                 
  179.                 if(pddContext!=null) {
  180.                     GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoMaxThreadsViolated(pddContext,warningOnly);
  181.                 }
  182.                 
  183.                 String msgDiagnostico = null;
  184.                 if(warningOnly) {
  185.                     msgDiag.getMessaggio_replaceKeywords(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_MAXREQUESTS_VIOLATED_WARNING_ONLY);
  186.                 }
  187.                 else {
  188.                     msgDiag.getMessaggio_replaceKeywords(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_MAXREQUESTS_VIOLATED);
  189.                 }
  190.                 he = GeneratoreMessaggiErrore.getMaxThreadsViolated(
  191.                         msgDiagnostico,
  192.                         this.erroreGenerico, pddContext
  193.                         );
  194.                 he.setEmettiDiagnostico(false);
  195.                 GeneratoreMessaggiErrore.configureHandlerExceptionByTipoErrore(serviceBinding, he, tipoErrore, includiDescrizioneErrore,log);
  196.                 if(warningOnly == false) {
  197.                     throw he;
  198.                 }
  199.             }
  200.             
  201.             long activeThreadsSyncAfterIncrement = activeThreadsSyncBeforeIncrement+1;
  202.             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_ACTIVE_THREADS, activeThreadsSyncAfterIncrement+""); // per policy applicabilità
  203.             
  204.             if(thresholdObj!=null){
  205.                 // Aggiungo l'informazione se la pdd risulta congestionata nel pddContext.
  206.                 if(pddContext!=null) {
  207.                     pddContext.addObject(CostantiControlloTraffico.PDD_CONTEXT_PDD_CONGESTIONATA, pddCongestionataSync);
  208.                 }
  209.                 
  210.                 if(emettiEventoPddCongestionata) {
  211.                     descriptionEventoPddCongestionata = this._buildDescription(maxThreadsPrimitive, thresholdPrimitive, msgDiag);
  212.                 }
  213.                 
  214.                 // Il timer dovra' vedere se esiste un evento di controllo del traffico.
  215.                 // Se non esiste utilizzera' il metodo 'isControlloTrafficoAttivo' per vedere che il controllo del traffico e' rientrato.
  216.             }
  217.         
  218.             if(he!=null) {
  219.                 // caso di warning only
  220.                 throw he;
  221.             }
  222.         }
  223.         finally{
  224.         
  225.             // *** ATTIVITA DA FARE FUORI DAL SYNCHRONIZED **
  226.                         
  227.             // fuori dal synchronized (per evitare deadlock)
  228.             if(emettiEventoMaxThreadsViolated){
  229.                 CategoriaEventoControlloTraffico evento = null;
  230.                 if(warningOnly) {
  231.                     evento = CategoriaEventoControlloTraffico.LIMITE_GLOBALE_RICHIESTE_SIMULTANEE_WARNING_ONLY;
  232.                 }
  233.                 else {
  234.                     evento = CategoriaEventoControlloTraffico.LIMITE_GLOBALE_RICHIESTE_SIMULTANEE;
  235.                 }
  236.                 NotificatoreEventi.getInstance().log(evento, dataEventoMaxThreadsViolated, descriptionEventoMaxThreadsViolated); 
  237.             }
  238.             
  239.             // fuori dal synchronized
  240.             if(emettiDiagnosticoMaxThreadRaggiunto){
  241.                 if(warningOnly) {
  242.                     msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_MAXREQUESTS_VIOLATED_WARNING_ONLY);
  243.                 }
  244.                 else {
  245.                     msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_MAXREQUESTS_VIOLATED);
  246.                 }
  247.             }
  248.             
  249.             // fuori dal synchronized (per evitare deadlock)
  250.             if(emettiEventoPddCongestionata){
  251.                 NotificatoreEventi.getInstance().log(CategoriaEventoControlloTraffico.CONGESTIONE_PORTA_DOMINIO, dataEventoPddCongestionata, descriptionEventoPddCongestionata); 
  252.             }
  253.             
  254.         }
  255.     }
  256.         
  257.     public void removeThread(Long maxThreadsObj, Integer thresholdObj, String idTransazione) throws Exception{
  258.         //synchronized (this.semaphore) {
  259.         if(maxThreadsObj==null) {
  260.             throw new Exception("MaxThreads param is null");
  261.         }
  262.         long maxThreadsPrimitive = maxThreadsObj.longValue();
  263.         int thresholdPrimitive = (thresholdObj!=null ? thresholdObj.intValue() : 0);
  264.         SemaphoreLock lock = this.lock.acquire("removeThread", idTransazione);
  265.         try {
  266.             this.activeThreads--;
  267.             
  268.             if(thresholdObj!=null && this.pddCongestionata){
  269. //              System.out.println("AGGORNO CONGESTIONE");
  270. //              boolean old = this.pddCongestionata;
  271.                 this.pddCongestionata = this._isPddCongestionata(maxThreadsPrimitive, thresholdPrimitive);
  272. //              if(old!=this.pddCongestionata){
  273. //                  System.out.println("OLD["+old+"] NEW["+this.pddCongestionata+"]");
  274. //              }
  275.             }
  276.             
  277.             //System.out.println("@@@removeThread (dopo): "+this.activeThreads);
  278.         }finally {
  279.             this.lock.release(lock, "removeThread", idTransazione);
  280.         }
  281.     }
  282.     
  283.     public long sizeActiveThreads(){
  284.         //synchronized (this.semaphore) {
  285.         SemaphoreLock lock = this.lock.acquireThrowRuntime("sizeActiveThreads");
  286.         try {
  287.             //System.out.println("@@@SIZE: "+this.activeThreads);
  288.             return this.activeThreads;
  289.         }finally {
  290.             this.lock.release(lock, "sizeActiveThreads");
  291.         }
  292.     }
  293.     
  294.     public Boolean isPortaDominioCongestionata(Long maxThreadsObj, Integer thresholdObj) {
  295.         //synchronized (this.semaphore) {
  296.         long maxThreadsPrimitive = maxThreadsObj.longValue();
  297.         int thresholdPrimitive = (thresholdObj!=null ? thresholdObj.intValue() : 0);
  298.         SemaphoreLock lock = this.lock.acquireThrowRuntime("isPortaDominioCongestionata");
  299.         try {
  300.             if(thresholdObj!=null){
  301.                 this.pddCongestionata = this._isPddCongestionata(maxThreadsPrimitive, thresholdPrimitive); // refresh per evitare che l'ultimo thread abbia lasciato attivo il controllo
  302.             }
  303.             else{
  304.                 this.pddCongestionata = false; // controllo non attivo
  305.             }
  306.             return this.pddCongestionata;
  307.         }finally {
  308.             this.lock.release(lock, "isPortaDominioCongestionata");
  309.         }
  310.     }
  311.     
  312.     
  313.     
  314.     
  315.     // Utilities
  316.     
  317.     private boolean _isPddCongestionata(long maxThreads, int threshold){
  318.         double dActiveT = maxThreads;
  319.         double dThreshold = threshold;
  320.         double t = dActiveT / 100d;
  321.         double tt = t * dThreshold;
  322.         int numeroThreadSoglia = (int)tt;
  323.         return this.activeThreads > numeroThreadSoglia;  // non ci vuole >=, nella govwayConsole si dice chiaramente 'Il controllo del traffico verrà attivato oltre le <numeroThreadSoglia> richieste '
  324.     }
  325.     private String _buildDescription(long maxThreads, int threshold, MsgDiagnostico msgDiag){
  326.         StringBuilder bf = new StringBuilder();
  327.         
  328.         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_MAX_THREADS_THRESHOLD, maxThreads+"");
  329.         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_CONTROLLO_TRAFFICO_THRESHOLD, threshold+"");
  330.         bf.append(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_PDD_CONGESTIONATA));
  331.         
  332.         return bf.toString();
  333.     }
  334.     
  335.     
  336. }

Created with JaCoCo 0.8.8.202204050719