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

  25. import java.io.ByteArrayOutputStream;
  26. import java.util.List;

  28. import org.openspcoop2.core.commons.CoreException;
  29. import org.openspcoop2.core.eventi.Evento;
  30. import org.openspcoop2.core.eventi.constants.CodiceEventoStatoGateway;
  31. import org.openspcoop2.core.eventi.constants.TipoEvento;
  32. import org.openspcoop2.core.eventi.constants.TipoSeverita;
  33. import org.openspcoop2.core.eventi.utils.SeveritaConverter;
  34. import org.openspcoop2.pdd.config.ClassNameProperties;
  35. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  36. import org.openspcoop2.pdd.config.DBManager;
  37. import org.openspcoop2.pdd.config.DBTransazioniManager;
  38. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  39. import org.openspcoop2.pdd.config.QueueManager;
  40. import org.openspcoop2.pdd.core.CostantiPdD;
  41. import org.openspcoop2.pdd.core.FileSystemSerializer;
  42. import org.openspcoop2.pdd.core.eventi.GestoreEventi;
  43. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  44. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  45. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  46. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  47. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  48. import org.openspcoop2.protocol.manifest.constants.ServiceBinding;
  49. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  50. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  51. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaProducer;
  52. import org.openspcoop2.utils.Utilities;
  53. import org.openspcoop2.utils.beans.WriteToSerializerType;
  54. import org.openspcoop2.utils.date.DateManager;
  55. import org.openspcoop2.utils.threads.BaseThread;
  56. import org.slf4j.Logger;

  58. /**
  59.  * Thread per la gestione del monitoraggio delle risorse
  60.  * 
  61.  *  
  62.  * @author Poli Andrea (apoli@link.it)
  63.  * @author $Author$
  64.  * @version $Rev$, $Date$
  65.  */
  66. public class TimerMonitoraggioRisorseThread extends BaseThread{

  68.     private static TimerState state = TimerState.OFF; // abilitato in OpenSPCoop2Startup al momento dell'avvio
  69.     
  70.     public static TimerState getSTATE() {
  71.         return state;
  72.     }
  73.     public static void setSTATE(TimerState sTATE) {
  74.         state = sTATE;
  75.     }

  77.     /** Indicazione di risorse correttamente disponibili */
  78.     private static boolean risorseDisponibili = true;
  79.     private static void setRisorseDisponibili(boolean risorseDisponibili) {
  80.         TimerMonitoraggioRisorseThread.risorseDisponibili = risorseDisponibili;
  81.     }
  82.     public static boolean isRisorseDisponibili() {
  83.         return risorseDisponibili;
  84.     }

  86.     /** Motivo dell'errore */
  87.     private static Exception risorsaNonDisponibileEccezione = null;
  88.     public static Exception getRisorsaNonDisponibile() {
  89.         return risorsaNonDisponibileEccezione;
  90.     }
  91.     private static void setRisorsaNonDisponibile(Exception risorsaNonDisponibile) {
  92.         TimerMonitoraggioRisorseThread.risorsaNonDisponibileEccezione = risorsaNonDisponibile;
  93.         TimerMonitoraggioRisorseThread.risorseDisponibili =  false;
  94.     }

  96.     /** Variabile che indica il Nome del modulo dell'architettura di OpenSPCoop rappresentato da questa classe */
  97.     public static final String ID_MODULO = "MonitoraggioRisorse";
  98.      
  99.     
  100.     /** Properties Reader */
  101.     private OpenSPCoop2Properties propertiesReader;
  102.     /** MessaggioDiagnostico */
  103.     private MsgDiagnostico msgDiag;
  104.     
  105.     /** LastImage */
  106.     private boolean lastCheck = true;
  107.     
  108.     /** Logger per debug */
  109.     private Logger logger = null;
  110.     private void logDebug(String msg) {
  111.         if(this.logger!=null) {
  112.             this.logger.debug(msg);
  113.         }
  114.     }
  115.     private void logWarn(String msg) {
  116.         if(this.logger!=null) {
  117.             this.logger.warn(msg);
  118.         }
  119.     }
  120.     
  121.     /** Risorsa: DB di OpenSPCoop */
  122.     private DBManager dbManager=null;
  123.     /** Risorsa: JMS di OpenSPCoop */
  124.     private QueueManager queueManager=null;
  125.     /** Risorsa: Configurazione di OpenSPCoop */
  126.     private ConfigurazionePdDManager configPdDReader=null;
  127.     /** Risorsa: Registri dei Servizi di OpenSPCoop */
  128.     private RegistroServiziManager registriPdDReader=null;
  129.     /** Risorsa: Tracciamenti Personalizzati */
  130.     private List<ITracciaProducer> tracciamentiPersonalizzati=null;
  131.     private List<String> tipiTracciamentiPersonalizzati=null;
  132.     /** Risorsa: Transazioni di OpenSPCoop */
  133.     private DBTransazioniManager dbTransazioniManager=null;
  134.     /** Risorsa: MsgDiagnostici Personalizzati */
  135.     private List<IDiagnosticProducer> msgDiagnosticiPersonalizzati=null;
  136.     private List<String> tipiMsgDiagnosticiPersonalizzati=null;
  137.     
  138.     private GestoreEventi gestoreEventi;
  139.     
  140.     /** Costruttore 
  141.      * @throws Exception */
  142.     public TimerMonitoraggioRisorseThread() throws Exception {
  143.         this.propertiesReader = OpenSPCoop2Properties.getInstance();
  144.         
  145.         this.msgDiag = MsgDiagnostico.newInstance(TimerMonitoraggioRisorseThread.ID_MODULO);
  146.         this.msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_MONITORAGGIO_RISORSE);
  147.         this.msgDiag.addKeyword(CostantiPdD.KEY_TIMER_MONITORAGGIO_RISORSE, TimerMonitoraggioRisorseThread.ID_MODULO);
  148.         
  149.         this.logger = OpenSPCoop2Logger.getLoggerOpenSPCoopResources();
  150.         if(this.propertiesReader.isAbilitatoControlloRisorseDB()){
  151.             this.dbManager = DBManager.getInstance();
  152.         }
  153.         if(this.propertiesReader.isAbilitatoControlloRisorseJMS()){
  154.             this.queueManager = QueueManager.getInstance();
  155.         }
  156.         if(this.propertiesReader.isAbilitatoControlloRisorseConfigurazione() || this.propertiesReader.isAbilitatoControlloValidazioneSemanticaConfigurazione()){
  157.             this.configPdDReader = ConfigurazionePdDManager.getInstance();
  158.         }
  159.         if(this.propertiesReader.isAbilitatoControlloRisorseRegistriServizi() || this.propertiesReader.isAbilitatoControlloValidazioneSemanticaRegistriServizi()){
  160.             this.registriPdDReader = RegistroServiziManager.getInstance();
  161.         }
  162.         if(this.propertiesReader.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
  163.             this.tracciamentiPersonalizzati = OpenSPCoop2Logger.getLoggerTracciamentoOpenSPCoopAppender();
  164.             this.tipiTracciamentiPersonalizzati = OpenSPCoop2Logger.getTipoTracciamentoOpenSPCoopAppender();
  165.             if(!this.propertiesReader.isTransazioniUsePddRuntimeDatasource()) {
  166.                 this.dbTransazioniManager = DBTransazioniManager.getInstance();
  167.             }
  168.         }
  169.         if(this.propertiesReader.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati()){
  170.             this.msgDiagnosticiPersonalizzati = OpenSPCoop2Logger.getLoggerMsgDiagnosticoOpenSPCoopAppender();
  171.             this.tipiMsgDiagnosticiPersonalizzati = OpenSPCoop2Logger.getTipoMsgDiagnosticoOpenSPCoopAppender();
  172.         }
  173.         if(this.propertiesReader.isControlloRisorseRegistrazioneEvento()) {
  174.             this.gestoreEventi = GestoreEventi.getInstance();
  175.         }       
  176.     }

  178.     @Override
  179.     public void process(){
  180.         // nop: ho ridefinito il metodo run
  181.     }
  182.     
  183.     @Override
  184.     public void run(){
  185.         
  186.         try {
  187.         
  188.             String sec = "secondi";
  189.             if(this.propertiesReader.getControlloRisorseCheckInterval() == 1)
  190.                 sec = "secondo";
  191.             this.msgDiag.addKeyword(CostantiPdD.KEY_TIMEOUT, this.propertiesReader.getControlloRisorseCheckInterval()+" "+sec);
  192.             this.msgDiag.logPersonalizzato("avvioEffettuato");
  193.             
  194.             String risorsaNonDisponibile = null;
  195.             while(!this.isStop()){
  196.                 boolean checkRisorseDisponibili = true;
  197.                 
  198.                 // Controllo che il sistema non sia andando in shutdown
  199.                 if(OpenSPCoop2Startup.contextDestroyed){
  200.                     this.logger.error("["+TimerMonitoraggioRisorseThread.ID_MODULO+"] Rilevato sistema in shutdown");
  201.                     return;
  202.                 }
  203.                 
  204.                 if(TimerState.ENABLED.equals(state)) {
  205.                 
  206.                     String descrizione = null;
  207.                     
  208.                     // Messaggi diagnostici personalizzati
  209.                     // Controllo per prima per sapere se posso usare poi i msg diagnostici per segnalare problemi
  210.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati()){
  211.                         String tipoMsgDiagnostico = null;
  212.                         try{
  213.                             for(int i=0; i< this.tipiMsgDiagnosticiPersonalizzati.size(); i++){
  214.                                 tipoMsgDiagnostico = this.tipiMsgDiagnosticiPersonalizzati.get(i);
  215.                                 this.logDebug("Controllo MsgDiagnosticoPersonalizzato ["+tipoMsgDiagnostico+"] (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati()+")");
  216.                                 Throwable t = null;
  217.                                 for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseMsgDiagnosticiPersonalizzati(); j++) {
  218.                                     try {
  219.                                         this.logDebug("MsgDiagnosticoPersonalizzato ["+tipoMsgDiagnostico+"] check '"+j+"' ...");
  220.                                         this.msgDiagnosticiPersonalizzati.get(i).isAlive();
  221.                                         this.logDebug("MsgDiagnosticoPersonalizzato ["+tipoMsgDiagnostico+"] check '"+j+"' ok");
  222.                                         t=null;
  223.                                         break;
  224.                                     }catch(Throwable tAlive) { // Volutamente Throwable
  225.                                         this.logDebug("MsgDiagnosticoPersonalizzato ["+tipoMsgDiagnostico+"] check '"+j+"' failed: "+tAlive.getMessage());
  226.                                         t = tAlive;
  227.                                         // faccio un altro tentativo
  228.                                         Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseMsgDiagnosticiPersonalizzati());
  229.                                     }
  230.                                 }
  231.                                 if(t!=null) {
  232.                                     throw t;
  233.                                 }
  234.                             }
  235.                         }catch(Throwable e){ // Volutamente Throwable
  236.                             risorsaNonDisponibile = "[MessaggioDiagnosticoAppender "+tipoMsgDiagnostico+"]";
  237.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  238.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  239.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  240.                             checkRisorseDisponibili = false;
  241.                         }
  242.                     }
  243.                     // Database
  244.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseDB()){
  245.                         try{
  246.                             this.logDebug("Controllo Database (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseDB()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseDB()+")");
  247.                             Throwable t = null;
  248.                             for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseDB(); j++) {
  249.                                 try {
  250.                                     this.logDebug("Database check '"+j+"' ...");
  251.                                     this.dbManager.isAlive();
  252.                                     this.logDebug("Database check '"+j+"' ok");
  253.                                     t=null;
  254.                                     break;
  255.                                 }catch(Throwable tAlive) { // Volutamente Throwable
  256.                                     this.logDebug("Database check '"+j+"' failed: "+tAlive.getMessage());
  257.                                     t = tAlive;
  258.                                     // faccio un altro tentativo
  259.                                     Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseDB());
  260.                                 }
  261.                             }
  262.                             if(t!=null) {
  263.                                 throw t;
  264.                             }   
  265.                         }catch(Throwable e){ // Volutamente Throwable
  266.                             risorsaNonDisponibile = "[Database]";
  267.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  268.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  269.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  270.                             checkRisorseDisponibili = false;
  271.                         }
  272.                     }
  273.                     // JMS
  274.                     if(this.propertiesReader.isServerJ2EE()){
  275.                         if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseJMS()){
  276.                             try{
  277.                                 this.logDebug("Controllo BrokerJMS (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseJMS()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseJMS()+")");
  278.                                 Throwable t = null;
  279.                                 for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseJMS(); j++) {
  280.                                     try {
  281.                                         this.logDebug("BrokerJMS check '"+j+"' ...");
  282.                                         this.queueManager.isAlive();
  283.                                         this.logDebug("BrokerJMS check '"+j+"' ok");
  284.                                         t=null;
  285.                                         break;
  286.                                     }catch(Throwable tAlive) {
  287.                                         this.logDebug("BrokerJMS check '"+j+"' failed: "+tAlive.getMessage());
  288.                                         t = tAlive;
  289.                                         // faccio un altro tentativo
  290.                                         Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseJMS());
  291.                                     }
  292.                                 }
  293.                                 if(t!=null) {
  294.                                     throw t;
  295.                                 }   
  296.                             }catch(Throwable e){ // Volutamente Throwable
  297.                                 risorsaNonDisponibile = "[Broker JMS]";
  298.                                 TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  299.                                 this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  300.                                 descrizione = risorsaNonDisponibile+" "+e.getMessage();
  301.                                 checkRisorseDisponibili = false;
  302.                             }
  303.                         }
  304.                     }
  305.                     // Configurazione
  306.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseConfigurazione()){
  307.                         try{
  308.                             this.logDebug("Controllo Configurazione (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseConfigurazione()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione()+")");
  309.                             Throwable t = null;
  310.                             for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseConfigurazione(); j++) {
  311.                                 try {
  312.                                     this.logDebug("Configurazione check '"+j+"' ...");
  313.                                     this.configPdDReader.isAlive();
  314.                                     this.logDebug("Configurazione check '"+j+"' ok");
  315.                                     t=null;
  316.                                     break;
  317.                                 }catch(Throwable tAlive) {
  318.                                     this.logDebug("Configurazione check '"+j+"' failed: "+tAlive.getMessage());
  319.                                     t = tAlive;
  320.                                     // faccio un altro tentativo
  321.                                     Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseConfigurazione());
  322.                                 }
  323.                             }
  324.                             if(t!=null) {
  325.                                 throw t;
  326.                             }   
  327.                         }catch(Throwable e){ // Volutamente Throwable
  328.                             risorsaNonDisponibile = "[Configurazione]";
  329.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  330.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  331.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  332.                             checkRisorseDisponibili = false;
  333.                         }
  334.                     }
  335.                     // Configurazione, validazione semantica
  336.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloValidazioneSemanticaConfigurazione()){
  337.                         try{
  338.                             this.logDebug("Controllo Validazione semantica della Configurazione");
  339.                             ClassNameProperties classNameReader = ClassNameProperties.getInstance();
  340.                             this.configPdDReader.validazioneSemantica(classNameReader.getConnettore(), 
  341.                                     classNameReader.getMsgDiagnosticoOpenSPCoopAppender(),
  342.                                     classNameReader.getTracciamentoOpenSPCoopAppender(),
  343.                                     classNameReader.getDumpOpenSPCoopAppender(),
  344.                                     classNameReader.getAutenticazionePortaDelegata(), classNameReader.getAutenticazionePortaApplicativa(), 
  345.                                     classNameReader.getAutorizzazionePortaDelegata(),classNameReader.getAutorizzazionePortaApplicativa(),
  346.                                     classNameReader.getAutorizzazioneContenutoPortaDelegata(),classNameReader.getAutorizzazioneContenutoPortaApplicativa(),
  347.                                     classNameReader.getIntegrazionePortaDelegata(),
  348.                                     classNameReader.getIntegrazionePortaApplicativa(),
  349.                                     true,
  350.                                     true,
  351.                                     true, null);
  352.                         }catch(Throwable e){ // Volutamente Throwable
  353.                             risorsaNonDisponibile = "[Validazione semantica della Configurazione]";
  354.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  355.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  356.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  357.                             checkRisorseDisponibili = false;
  358.                         }
  359.                     }
  360.                     // Registro dei Servizi
  361.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseRegistriServizi()){
  362.                         try{
  363.                             this.logDebug("Controllo Registri dei Servizi (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseRegistriServizi()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi()+")");
  364.                             Throwable t = null;
  365.                             for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseRegistriServizi(); j++) {
  366.                                 try {
  367.                                     this.logDebug("Registri dei Servizi check '"+j+"' ...");
  368.                                     this.registriPdDReader.isAlive(this.propertiesReader.isControlloRisorseRegistriRaggiungibilitaTotale());
  369.                                     this.logDebug("Registri dei Servizi check '"+j+"' ok");
  370.                                     t=null;
  371.                                     break;
  372.                                 }catch(Throwable tAlive) { // Volutamente Throwable
  373.                                     this.logDebug("Registri dei Servizi check '"+j+"' failed: "+tAlive.getMessage());
  374.                                     t = tAlive;
  375.                                     // faccio un altro tentativo
  376.                                     Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseRegistriServizi());
  377.                                 }
  378.                             }
  379.                             if(t!=null) {
  380.                                 throw t;
  381.                             }   
  382.                         }catch(Throwable e){ // Volutamente Throwable
  383.                             risorsaNonDisponibile = "[Registri dei Servizi]";
  384.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  385.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  386.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  387.                             checkRisorseDisponibili = false;
  388.                         }
  389.                     }
  390.                     // Registro dei Servizi, validazione semantica
  391.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloValidazioneSemanticaRegistriServizi()){
  392.                         try{
  393.                             ProtocolFactoryManager pFactoryManager = ProtocolFactoryManager.getInstance();
  394.                             this.logDebug("Controllo Validazione semantica del Registri dei Servizi");
  395.                             this.registriPdDReader.validazioneSemantica(this.propertiesReader.isControlloRisorseRegistriRaggiungibilitaTotale(), 
  396.                                     this.propertiesReader.isValidazioneSemanticaRegistroServiziCheckURI(), 
  397.                                     pFactoryManager.getOrganizationTypesAsArray(),
  398.                                     pFactoryManager.getServiceTypesAsArray(ServiceBinding.SOAP),
  399.                                     pFactoryManager.getServiceTypesAsArray(ServiceBinding.REST),
  400.                                     ClassNameProperties.getInstance().getConnettore(),
  401.                                     true,
  402.                                     true,
  403.                                     null);
  404.                         }catch(Throwable e){ // Volutamente Throwable
  405.                             risorsaNonDisponibile = "[Validazione semantica del Registri dei Servizi]";
  406.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  407.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  408.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  409.                             checkRisorseDisponibili = false;
  410.                         }
  411.                     }
  412.                     // Tracciamenti personalizzati
  413.                     if(checkRisorseDisponibili && this.propertiesReader.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
  414.                         String tipoTracciamento = null;
  415.                         try{
  416.                             for(int i=0; i< this.tipiTracciamentiPersonalizzati.size(); i++){
  417.                                 tipoTracciamento = this.tipiTracciamentiPersonalizzati.get(i);
  418.                                 this.logDebug("Controllo TracciamentoPersonalizzato ["+tipoTracciamento+"] (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati()+")");
  419.                                 Throwable t = null;
  420.                                 for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati(); j++) {
  421.                                     try {
  422.                                         this.logDebug("TracciamentoPersonalizzato ["+tipoTracciamento+"] check '"+j+"' ...");
  423.                                         this.tracciamentiPersonalizzati.get(i).isAlive();
  424.                                         this.logDebug("TracciamentoPersonalizzato ["+tipoTracciamento+"] check '"+j+"' ok");
  425.                                         t=null;
  426.                                         break;
  427.                                     }catch(Throwable tAlive) { // Volutamente Throwable
  428.                                         this.logDebug("TracciamentoPersonalizzato ["+tipoTracciamento+"] check '"+j+"' failed: "+tAlive.getMessage());
  429.                                         t = tAlive;
  430.                                         // faccio un altro tentativo
  431.                                         Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati());
  432.                                     }
  433.                                 }
  434.                                 if(t!=null) {
  435.                                     throw t;
  436.                                 }
  437.                             }
  438.                         }catch(Throwable e){ // Volutamente Throwable
  439.                             risorsaNonDisponibile = "[TracciamentoAppender "+tipoTracciamento+"]";
  440.                             TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  441.                             this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  442.                             descrizione = risorsaNonDisponibile+" "+e.getMessage();
  443.                             checkRisorseDisponibili = false;
  444.                         }
  445.                         
  446.                         // nel tracciamento considero anche le transazioni
  447.                         if(checkRisorseDisponibili && this.propertiesReader.isTransazioniUsePddRuntimeDatasource()==false) {
  448.                             try{
  449.                                 this.logDebug("Controllo Database Transazioni (iterazioni:"+this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati()+" checkInterval:"+this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati()+")");
  450.                                 Throwable t = null;
  451.                                 for (int j = 0; j < this.propertiesReader.getNumeroIterazioniFalliteControlloRisorseTracciamentiPersonalizzati(); j++) {
  452.                                     try {
  453.                                         this.logDebug("Database Transazioni check '"+j+"' ...");
  454.                                         this.dbTransazioniManager.isAlive();
  455.                                         this.logDebug("Database Transazioni check '"+j+"' ok");
  456.                                         t=null;
  457.                                         break;
  458.                                     }catch(Throwable tAlive) { // Volutamente Throwable
  459.                                         this.logDebug("Database Transazioni check '"+j+"' failed: "+tAlive.getMessage());
  460.                                         t = tAlive;
  461.                                         // faccio un altro tentativo
  462.                                         Utilities.sleep(this.propertiesReader.getIterazioniFalliteCheckIntervalControlloRisorseTracciamentiPersonalizzati());
  463.                                     }
  464.                                 }
  465.                                 if(t!=null) {
  466.                                     throw t;
  467.                                 }
  468.                             }catch(Throwable e){ // Volutamente Throwable
  469.                                 risorsaNonDisponibile = "[DatabaseTransazioni]";
  470.                                 TimerMonitoraggioRisorseThread.setRisorsaNonDisponibile(new CoreException(risorsaNonDisponibile+" "+e.getMessage(),e));
  471.                                 this.logger.error(risorsaNonDisponibile+" "+e.getMessage(),e);
  472.                                 descrizione = risorsaNonDisponibile+" "+e.getMessage();
  473.                                 checkRisorseDisponibili = false;
  474.                             }
  475.                         }
  476.                     }
  477.                     
  478.                 
  479.                     // avvisi
  480.                     if(risorsaNonDisponibile!=null)
  481.                         this.msgDiag.addKeyword(CostantiPdD.KEY_RISORSA_NON_DISPONIBILE, risorsaNonDisponibile);
  482.                     if(!checkRisorseDisponibili && this.lastCheck){
  483.                         if(risorsaNonDisponibile!=null && (risorsaNonDisponibile.startsWith("[MessaggioDiagnosticoAppender")==false) ){
  484.                             if(risorsaNonDisponibile.startsWith("[Validazione semantica")){
  485.                                 this.msgDiag.logPersonalizzato("validazioneSemanticaFallita");
  486.                             }else{
  487.                                 this.msgDiag.logPersonalizzato("risorsaNonDisponibile");
  488.                             }
  489.                         }
  490.                         else
  491.                             this.logWarn("Il Monitoraggio delle risorse ha rilevato che la risorsa "+risorsaNonDisponibile+" non e' raggiungibile, tutti i servizi/moduli della porta di dominio sono momentanemanete sospesi.");
  492.                         
  493.                         registraEvento(false, descrizione);
  494.                         
  495.                     }else if(checkRisorseDisponibili && !this.lastCheck){
  496.                         this.msgDiag.logPersonalizzato("risorsaRitornataDisponibile");
  497.                         risorsaNonDisponibile = null;
  498.                         
  499.                         registraEvento(true, this.msgDiag.getMessaggio_replaceKeywords("risorsaRitornataDisponibile"));
  500.                     }
  501.                     this.lastCheck = checkRisorseDisponibili;
  502.                     TimerMonitoraggioRisorseThread.setRisorseDisponibili(checkRisorseDisponibili);
  503.                     
  504.                 }
  505.                 else {
  506.                     this.logger.info("Timer "+ID_MODULO+" disabilitato");
  507.                 }
  508.                 
  509.                             
  510.                 // CheckInterval
  511.                 this.sleepForNextCheck((int) this.propertiesReader.getControlloRisorseCheckInterval(), 1000);
  512.                 
  513.             } 
  514.         }finally {
  515.             this.finished();
  516.         }
  517.     }
  518.     
  519.     private void registraEvento(boolean risorseDisponibili, String descrizione) {
  520.         String clusterID = this.propertiesReader.getClusterId(false);
  521.         Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopResources();
  522.         Evento evento = null;
  523.         try{
  524.             if(this.gestoreEventi!=null &&
  525.                 this.propertiesReader.isControlloRisorseRegistrazioneEvento()){
  526.                 evento = new Evento();
  527.                 evento.setTipo(TipoEvento.STATO_GATEWAY.getValue());
  528.                 evento.setCodice(risorseDisponibili ? CodiceEventoStatoGateway.RISORSE_SISTEMA_DISPONIBILI.getValue() : CodiceEventoStatoGateway.RISORSE_SISTEMA_NON_DISPONIBILI.getValue());
  529.                 evento.setSeverita(risorseDisponibili ? SeveritaConverter.toIntValue(TipoSeverita.INFO) : SeveritaConverter.toIntValue(TipoSeverita.ERROR));
  530.                 evento.setClusterId(clusterID);
  531.                 evento.setDescrizione(descrizione);
  532.                 this.gestoreEventi.log(evento,true);
  533.             }
  534.         }catch(Throwable e){ // Volutamente Throwable
  535.             // L'errore puo' avvenire poiche' lo shutdown puo' anche disattivare il datasource
  536.             log.debug("Errore durante la registrazione dell'evento (risorse disponibili:"+descrizione+" '"+descrizione+"'): "+e.getMessage(),e);
  537.             if(evento!=null){
  538.                 try{
  539.                     if(evento.getOraRegistrazione()==null){
  540.                         evento.setOraRegistrazione(DateManager.getDate());
  541.                     }
  542.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  543.                     evento.writeTo(bout, WriteToSerializerType.XML_JAXB);
  544.                     bout.flush();
  545.                     bout.close();
  546.                     FileSystemSerializer.getInstance().registraEvento(bout.toByteArray(), evento.getOraRegistrazione());
  547.                 }catch(Exception eSerializer){
  548.                     log.error("Errore durante la registrazione su file system dell'evento: "+eSerializer.getMessage(),eSerializer);
  549.                 }
  550.             }
  551.         }
  552.     }
  553. }
Created with JaCoCo 0.8.8.202204050719