TimerEventiThread.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.timers;


  24. import java.io.File;
  25. import java.io.FileInputStream;
  26. import java.sql.Connection;
  27. import java.util.Date;
  28. import java.util.List;

  30. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  31. import org.openspcoop2.pdd.config.DBTransazioniManager;
  32. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  33. import org.openspcoop2.pdd.config.Resource;
  34. import org.openspcoop2.pdd.core.controllo_traffico.NotificatoreEventi;
  35. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.GestorePolicyAttive;
  36. import org.openspcoop2.pdd.core.handlers.HandlerException;
  37. import org.openspcoop2.utils.UtilsException;
  38. import org.openspcoop2.utils.date.DateManager;
  39. import org.openspcoop2.utils.threads.BaseThread;
  40. import org.slf4j.Logger;


  43. /**     
  44.  * TimerEventiThread
  45.  *
  46.  * @author Poli Andrea (poli@link.it)
  47.  * @author $Author$
  48.  * @version $Rev$, $Date$
  49.  */
  50. public class TimerEventiThread extends BaseThread{

  52.     private static TimerState STATE = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  53.     
  54.     public static TimerState getSTATE() {
  55.         return STATE;
  56.     }
  57.     public static void setSTATE(TimerState sTATE) {
  58.         STATE = sTATE;
  59.     }

  61.     public static final String ID_MODULO = "TimerEventi";
  62.         
  63.     /** Logger utilizzato per debug. */
  64.     private Logger log = null;
  65.     
  66.     /** Indicazione se deve essere effettuato il log delle query */
  67.     private boolean debug = false;  
  68.     
  69.     
  70.     private OpenSPCoop2Properties properties;
  71.     
  72.     /** NotificatoreEventi */
  73.     private NotificatoreEventi notificatoreEventi = null;
  74.     
  75.     /** LastInterval */
  76.     private Date lastInterval;
  77.     
  78.     /** ConnectionTimeout */
  79.     private int checkConnectionTimeoutEveryXTimes = 1;
  80.     private int offsetConnectionTimeoutEveryXTimes = 0;
  81.     private Date lastIntervalConnectionTimeout;
  82.     
  83.     /** RequestReadTimeout */
  84.     private int checkRequestReadTimeoutEveryXTimes = 1;
  85.     private int offsetRequestReadTimeoutEveryXTimes = 0;
  86.     private Date lastIntervalRequestReadTimeout;
  87.     
  88.     private int checkReadTimeoutEveryXTimes = 1;
  89.     private int offsetReadTimeoutEveryXTimes = 0;
  90.     private Date lastIntervalReadTimeout;
  91.     
  92.     /** Immagine */
  93.     @SuppressWarnings("unused")
  94.     private boolean forceCheckPrimoAvvio = false;
  95.     
  96.     private static boolean inizializzazioneAttiva = false;
  97.     public static boolean isInizializzazioneAttiva() {
  98.         return inizializzazioneAttiva;
  99.     }
  100.     public static void setInizializzazioneAttiva(boolean inizializzazioneAttiva) {
  101.         TimerEventiThread.inizializzazioneAttiva = inizializzazioneAttiva;
  102.     }
  103.     
  104.     /** Costruttore */
  105.     @SuppressWarnings("deprecation")
  106.     public TimerEventiThread(Logger log) throws Exception{
  107.     
  108.         this.log = log;
  109.     
  110.         this.properties = OpenSPCoop2Properties.getInstance();
  111.         this.setTimeout(this.properties.getEventiTimerIntervalSeconds());
  112.         
  113.         this.checkConnectionTimeoutEveryXTimes = this.properties.getEventiTimerIntervalConnectionTimeoutEveryXTimes();
  114.         this.checkRequestReadTimeoutEveryXTimes = this.properties.getEventiTimerIntervalRequestReadTimeoutEveryXTimes();
  115.         this.checkReadTimeoutEveryXTimes = this.properties.getEventiTimerIntervalReadTimeoutEveryXTimes();
  116.         
  117.         // Eventi per Controllo Traffico
  118.         if(this.properties.isControlloTrafficoEnabled()){
  119.             this.notificatoreEventi = NotificatoreEventi.getInstance();
  120.             
  121.             // Il meccanismo di ripristino dell'immagine degli eventi non sembra funzionare
  122.             // Lascio comunque il codice se in futuro si desidera approfindire la questione
  123.             if(inizializzazioneAttiva) {
  124.                 List<PolicyGroupByActiveThreadsType> tipiGestorePolicyRateLimiting = null;
  125.                 try{
  126.                     tipiGestorePolicyRateLimiting = GestorePolicyAttive.getTipiGestoriAttivi();
  127.                 }catch(Throwable e){
  128.                     this.log.error("Errore durante l'inizializzazione dell'immagine degli eventi per il Controllo del Traffico: "+e.getMessage(),e);
  129.                 }
  130.                 if(tipiGestorePolicyRateLimiting!=null && !tipiGestorePolicyRateLimiting.isEmpty()) {
  131.                     for (PolicyGroupByActiveThreadsType type : tipiGestorePolicyRateLimiting) {
  132.                         File fDati = null;
  133.                         try{
  134.                             File fRepository = this.properties.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  135.                             if(fRepository!=null){
  136.                                 if(fRepository.exists()==false){
  137.                                     throw new Exception("Directory ["+fRepository.getAbsolutePath()+"] not exists");
  138.                                 }
  139.                                 if(fRepository.isDirectory()==false){
  140.                                     throw new Exception("File ["+fRepository.getAbsolutePath()+"] is not directory");
  141.                                 }
  142.                                 if(fRepository.canRead()==false){
  143.                                     throw new Exception("File ["+fRepository.getAbsolutePath()+"] cannot read");
  144.                                 }
  145.                                 if(fRepository.canWrite()==false){
  146.                                     throw new Exception("File ["+fRepository.getAbsolutePath()+"] cannot write");
  147.                                 }
  148.                                 fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoEventiImage(type));
  149.                                 if(fDati.exists() && fDati.canRead() && fDati.length()>0){
  150.                                     FileInputStream fin = new FileInputStream(fDati);
  151.                                     this.notificatoreEventi.initialize(fin);
  152.                                     if(!fDati.delete()) {
  153.                                         // ignore
  154.                                     }
  155.                                     this.forceCheckPrimoAvvio = true;
  156.                                 }
  157.                             }
  158.                         }catch(Exception e){
  159.                             String img = null;
  160.                             if(fDati!=null){
  161.                                 img = fDati.getAbsolutePath();
  162.                             }
  163.                             throw new HandlerException("Inizializzazione dell'immagine degli eventi ["+img+"] per il Controllo del Traffico non riuscita: "+e.getMessage(),e);
  164.                         }
  165.                     }
  166.                 }
  167.             }
  168.         }
  169.         
  170.         this.lastInterval = DateManager.getDate();
  171.         this.lastIntervalConnectionTimeout = DateManager.getDate();
  172.         this.lastIntervalRequestReadTimeout = DateManager.getDate();
  173.         this.lastIntervalReadTimeout = DateManager.getDate();
  174.         
  175.         this.debug = this.properties.isEventiDebug();

  177.     }
  178.     
  179.     
  180.     @Override
  181.     public void process(){
  182.     
  183.         if(TimerState.ENABLED.equals(STATE)) {
  184.         
  185.             DBTransazioniManager dbManager = null;
  186.             Resource r = null;
  187.             try{
  188.                 dbManager = DBTransazioniManager.getInstance();
  189.                 r = dbManager.getResource(this.properties.getIdentitaPortaDefaultWithoutProtocol(), ID_MODULO, null);
  190.                 if(r==null){
  191.                     throw new UtilsException("Risorsa al database non disponibile");
  192.                 }
  193.                 Connection con = (Connection) r.getResource();
  194.                 if(con == null)
  195.                     throw new UtilsException("Connessione non disponibile");    
  196.                 
  197.                 if(this.properties.isControlloTrafficoEnabled()){
  198.                     
  199.                     try{
  200.                         this.lastInterval = this.notificatoreEventi.process(this.log, this.getTimeout(), this.lastInterval, con, this.debug);
  201.                     }catch(Exception e){
  202.                         this.log.error("Errore durante la generazione degli eventi per il controllo del traffico: "+e.getMessage(),e);
  203.                     }
  204.                     
  205.                     // Comprensione offset per analisi connection timeout events
  206.                     try{
  207.                         boolean analyzeConnectionTimeout = isAnalyzeConnectionTimeout();
  208.                         if(analyzeConnectionTimeout) {
  209.                             this.lastIntervalConnectionTimeout = this.notificatoreEventi.processConnectionTimeout(this.log, (this.getTimeout()*this.checkConnectionTimeoutEveryXTimes), this.lastIntervalConnectionTimeout, con, this.debug);
  210.                         }
  211.                         else {
  212.                             this.notificatoreEventi.emitProcessConnectionTimeoutSkip(this.log, this.debug, this.offsetConnectionTimeoutEveryXTimes, this.checkConnectionTimeoutEveryXTimes);
  213.                         }
  214.                     }catch(Exception e){
  215.                         this.log.error("Errore durante la generazione degli eventi di connection timeout: "+e.getMessage(),e);
  216.                     }
  217.                     
  218.                     // Comprensione offset per analisi request read timeout events
  219.                     try {
  220.                         boolean analyzeRequestReadTimeout = isAnalyzeRequestReadTimeout();
  221.                         if(analyzeRequestReadTimeout) {
  222.                             this.lastIntervalRequestReadTimeout = this.notificatoreEventi.processRequestReadTimeout(this.log, (this.getTimeout()*this.checkRequestReadTimeoutEveryXTimes), this.lastIntervalRequestReadTimeout, con, this.debug);
  223.                         }
  224.                         else {
  225.                             this.notificatoreEventi.emitProcessRequestReadTimeoutSkip(this.log, this.debug, this.offsetRequestReadTimeoutEveryXTimes, this.checkRequestReadTimeoutEveryXTimes);
  226.                         }
  227.                     }catch(Exception e){
  228.                         this.log.error("Errore durante la generazione degli eventi di request read timeout: "+e.getMessage(),e);
  229.                     }
  230.                     
  231.                     // Comprensione offset per analisi read timeout events
  232.                     try {
  233.                         boolean analyzeReadTimeout = isAnalyzeReadTimeout();
  234.                         if(analyzeReadTimeout) {
  235.                             this.lastIntervalReadTimeout = this.notificatoreEventi.processReadTimeout(this.log, (this.getTimeout()*this.checkReadTimeoutEveryXTimes), this.lastIntervalReadTimeout, con, this.debug);
  236.                         }
  237.                         else {
  238.                             this.notificatoreEventi.emitProcessReadTimeoutSkip(this.log, this.debug, this.offsetReadTimeoutEveryXTimes, this.checkReadTimeoutEveryXTimes);
  239.                         }
  240.                     }catch(Exception e){
  241.                         this.log.error("Errore durante la generazione degli eventi di request read timeout: "+e.getMessage(),e);
  242.                     }
  243.                     
  244.                 }
  245.                                 
  246.                 // Aggiungere in futuro altre gestione degli eventi
  247.                 
  248.             }catch(Exception e){
  249.                 this.log.error("Errore durante la generazione degli eventi: "+e.getMessage(),e);
  250.             }finally{
  251.                 try{
  252.                     if(r!=null)
  253.                         dbManager.releaseResource(this.properties.getIdentitaPortaDefaultWithoutProtocol(), ID_MODULO, r);
  254.                 }catch(Exception eClose){
  255.                     // ignore
  256.                 }
  257.             }
  258.             
  259.         }
  260.         else {
  261.             this.log.info("Timer "+ID_MODULO+" disabilitato");
  262.         }
  263.                 
  264.     }
  265.     
  266.     @Override
  267.     public void close(){
  268.         this.log.info("Thread per la generazione degli eventi terminato");
  269.     }
  270.             
  271.     private boolean isAnalyzeConnectionTimeout() {
  272.         this.offsetConnectionTimeoutEveryXTimes++;
  273.         boolean esito = false;
  274.         if(this.offsetConnectionTimeoutEveryXTimes==this.checkConnectionTimeoutEveryXTimes) {
  275.             /**System.out.println("CONNECTION TIMEOUT CHECK '"+this.offsetConnectionTimeoutEveryXTimes+"'=='"+this.checkConnectionTimeoutEveryXTimes+"' TRUE");*/
  276.             esito = true;
  277.             this.offsetConnectionTimeoutEveryXTimes = 0;
  278.         }
  279.         /**else {
  280.             System.out.println("CONNECTION TIMEOUT CHECK '"+this.offsetConnectionTimeoutEveryXTimes+"'<>'"+this.checkConnectionTimeoutEveryXTimes+"' FALSE");
  281.         }*/
  282.         return esito;
  283.     }
  284.     private boolean isAnalyzeRequestReadTimeout() {
  285.         this.offsetRequestReadTimeoutEveryXTimes++;
  286.         boolean esito = false;
  287.         if(this.offsetRequestReadTimeoutEveryXTimes==this.checkRequestReadTimeoutEveryXTimes) {
  288.             /**System.out.println("REQUEST READ TIMEOUT CHECK '"+this.offsetRequestReadTimeoutEveryXTimes+"'=='"+this.checkRequestReadTimeoutEveryXTimes+"' TRUE");*/
  289.             esito = true;
  290.             this.offsetRequestReadTimeoutEveryXTimes = 0;
  291.         }
  292.         /**else {
  293.             System.out.println("REQUEST READ TIMEOUT CHECK '"+this.offsetRequestReadTimeoutEveryXTimes+"'<>'"+this.checkRequestReadTimeoutEveryXTimes+"' FALSE");
  294.         }*/
  295.         return esito;
  296.     }
  297.     private boolean isAnalyzeReadTimeout() {
  298.         this.offsetReadTimeoutEveryXTimes++;
  299.         boolean esito = false;
  300.         if(this.offsetReadTimeoutEveryXTimes==this.checkReadTimeoutEveryXTimes) {
  301.             /**System.out.println("READ TIMEOUT CHECK '"+this.offsetReadTimeoutEveryXTimes+"'=='"+this.checkReadTimeoutEveryXTimes+"' TRUE");*/
  302.             esito = true;
  303.             this.offsetReadTimeoutEveryXTimes = 0;
  304.         }
  305.         else {
  306.             /**System.out.println("READ TIMEOUT CHECK '"+this.offsetReadTimeoutEveryXTimes+"'<>'"+this.checkReadTimeoutEveryXTimes+"' FALSE");*/
  307.         }
  308.         return esito;
  309.     }
  310. }
Created with JaCoCo 0.8.8.202204050719