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




  24. package org.openspcoop2.pdd.logger;


  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.InputStream;
  30. import java.io.StringReader;
  31. import java.util.ArrayList;
  32. import java.util.Date;
  33. import java.util.Enumeration;
  34. import java.util.List;
  35. import java.util.Map;
  36. import java.util.Properties;

  38. import org.openspcoop2.core.commons.CoreException;
  39. import org.openspcoop2.core.config.MessaggiDiagnostici;
  40. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  44. import org.openspcoop2.core.statistiche.constants.TipoIntervalloStatistico;
  45. import org.openspcoop2.pdd.config.ClassNameProperties;
  46. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  47. import org.openspcoop2.pdd.core.CostantiPdD;
  48. import org.openspcoop2.pdd.core.IPdDContextSerializer;
  49. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  50. import org.openspcoop2.protocol.engine.builder.DateBuilder;
  51. import org.openspcoop2.protocol.engine.utils.NamingUtils;
  52. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  53. import org.openspcoop2.protocol.sdk.diagnostica.IDiagnosticProducer;
  54. import org.openspcoop2.protocol.sdk.diagnostica.MsgDiagnostico;
  55. import org.openspcoop2.protocol.sdk.dump.IDumpProducer;
  56. import org.openspcoop2.protocol.sdk.tracciamento.ITracciaProducer;
  57. import org.openspcoop2.utils.LoggerWrapperFactory;
  58. import org.openspcoop2.utils.Utilities;
  59. import org.openspcoop2.utils.properties.CollectionProperties;
  60. import org.openspcoop2.utils.properties.PropertiesUtilities;
  61. import org.openspcoop2.utils.resources.Charset;
  62. import org.openspcoop2.utils.resources.Loader;
  63. import org.slf4j.Logger;

  65. /**
  66.  * Contiene la definizione un Logger utilizzato dai nodi dell'infrastruttura di OpenSPCoop
  67.  * per la registrazione di messaggi riguardanti :.
  68.  * <ul>
  69.  * <li> Tracciamento
  70.  * <li> MsgDiagnostici
  71.  * </ul>
  72.  *
  73.  * @author Poli Andrea (apoli@link.it)
  74.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  75.  * @author $Author$
  76.  * @version $Rev$, $Date$
  77.  */

  79. public class OpenSPCoop2Logger {

  81.     /**  Logger log4j utilizzato per scrivere i tracciamenti */
  82.     protected static Logger loggerTracciamento = null;
  83.     /** Logger log4j utilizzato per scrivere i tracciamenti: impostazione */
  84.     public static boolean loggerTracciamentoAbilitato = false;
  85.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici */
  86.     protected static org.apache.logging.log4j.Logger loggerMsgDiagnostico = null;
  87.     /** Logger log4j utilizzato per scrivere i msg diagnostici: impostazione */
  88.     public static boolean loggerMsgDiagnosticoAbilitato = false;
  89.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici */
  90.     protected static org.apache.logging.log4j.Logger loggerOpenSPCoop2 = null;
  91.     /** Logger log4j utilizzato per scrivere i msg diagnostici 'readable': impostazione */
  92.     public static boolean loggerMsgDiagnosticoReadableAbilitato = false;
  93.     /**  Logger log4j utilizzato per scrivere i msgDiagnostici del servizio di IntegrationManager */
  94.     protected static org.apache.logging.log4j.Logger loggerIntegrationManager = null;
  95.     /** Logger log4j utilizzato per scrivere i msg diagnostici 'readable' del servizio di IntegrationManager: impostazione */
  96.     public static boolean loggerIntegrationManagerAbilitato = false;
  97.     /**  Logger log4j utilizzato per effettuare un dump dei messaggi applicativi */
  98.     protected static Logger loggerDump = null;
  99.     /** Logger log4j utilizzato per scrivere i dump applicativi: impostazione */
  100.     public static boolean loggerDumpAbilitato = false;
  101.     /**  Logger log4j utilizzato per segnalare a video errori gravi (FATAL) o di informazione sull'inizializzazione (INFO)*/
  102.     protected static Logger loggerOpenSPCoopConsole = LoggerWrapperFactory.getLogger("govway.startup");
  103.     /** Logger log4j utilizzato per segnalare a video errori gravi (FATAL) o di informazione sull'inizializzazione (INFO) */
  104.     protected static boolean loggerOpenSPCoopConsoleStartupAgganciatoLog = false;
  105.     /**  Logger log4j utilizzato per il core di OpenSPCoop */
  106.     protected static Logger loggerOpenSPCoopCore = null;
  107.     /**  Logger log4j utilizzato per registrare le operazioni dei Timer che ripuliscono i repository buste e messaggi*/
  108.     protected static Logger loggerOpenSPCoopTimers = null;
  109.     /**  Logger log4j utilizzato per registrare le operazioni di monitoraggio delle risorse utilizzate dalla PdD (Timer che verficano le risorse della PdD) */
  110.     protected static Logger loggerOpenSPCoopResources = null;
  111.     protected static org.apache.logging.log4j.Logger loggerOpenSPCoopResourcesAsLoggerImpl = null;
  112.     /**  Logger log4j utilizzato per la configurazione di sistema */
  113.     protected static Logger loggerOpenSPCoopConfigurazioneSistema = null;
  114.     /**  Logger log4j utilizzato per il servizio proxy */
  115.     protected static Logger loggerOpenSPCoopProxy = null;
  116.     /**  Logger log4j utilizzato per i connettori */
  117.     protected static Logger loggerOpenSPCoopConnettori = null;
  118.     /**  Logger log4j utilizzato per i dati binari del servizio PD */
  119.     protected static Logger loggerOpenSPCoopDumpBinarioPD = null;
  120.     /**  Logger log4j utilizzato per i dati binari del servizio PA */
  121.     protected static Logger loggerOpenSPCoopDumpBinarioPA = null;
  122.     /**  Logger log4j utilizzato per gli eventi */
  123.     protected static Logger loggerOpenSPCoopEventi = null;
  124.     protected static Logger loggerOpenSPCoopEventiError = null;
  125.     /**  Logger log4j utilizzato per le transazioni */
  126.     protected static Logger loggerOpenSPCoopTransazioni = null;
  127.     protected static Logger loggerOpenSPCoopTransazioniError = null;
  128.     protected static Logger loggerOpenSPCoopTransazioniDevNull = null;
  129.     /**  Logger log4j utilizzato per le transazioni */
  130.     protected static Logger loggerOpenSPCoopTransazioniSql = null;
  131.     protected static Logger loggerOpenSPCoopTransazioniSqlError = null;
  132.     /**  Logger log4j utilizzato per le transazioni stateful */
  133.     protected static Logger loggerOpenSPCoopTransazioniStateful = null;
  134.     protected static Logger loggerOpenSPCoopTransazioniStatefulError = null;
  135.     /**  Logger log4j utilizzato per le transazioni stateful */
  136.     protected static Logger loggerOpenSPCoopTransazioniStatefulSql = null;
  137.     protected static Logger loggerOpenSPCoopTransazioniStatefulSqlError = null;
  138.     /**  Logger log4j utilizzato per le transazioni, per registrare le operazioni lente */
  139.     protected static Logger loggerOpenSPCoopTransazioniSlowLog = null;
  140.     /**  Logger log4j utilizzato per attività di file system recovery */
  141.     protected static Logger loggerOpenSPCoopFileSystemRecovery = null;
  142.     protected static Logger loggerOpenSPCoopFileSystemRecoveryError = null;
  143.     /**  Logger log4j utilizzato per attività di file system recovery (sql) */
  144.     protected static Logger loggerOpenSPCoopFileSystemRecoverySql = null;
  145.     protected static Logger loggerOpenSPCoopFileSystemRecoverySqlError = null;
  146.     /**  Logger log4j utilizzato per il Controllo del Traffico */
  147.     protected static Logger loggerOpenSPCoopControlloTraffico = null;
  148.     protected static Logger loggerOpenSPCoopControlloTrafficoError = null;
  149.     /**  Logger log4j utilizzato per il Controllo del Traffico (sql) */
  150.     protected static Logger loggerOpenSPCoopControlloTrafficoSql = null;
  151.     protected static Logger loggerOpenSPCoopControlloTrafficoSqlError = null;
  152.     /**  Logger log4j utilizzato per gli Allarmi */
  153.     protected static Logger loggerOpenSPCoopAllarmi = null;
  154.     protected static Logger loggerOpenSPCoopAllarmiError = null;
  155.     /**  Logger log4j utilizzato per gli Allarmi (sql) */
  156.     protected static Logger loggerOpenSPCoopAllarmiSql = null;
  157.     protected static Logger loggerOpenSPCoopAllarmiSqlError = null;
  158.     /**  Logger log4j utilizzato per le statistiche */
  159.     protected static Logger loggerOpenSPCoopStatisticheOrarie = null;
  160.     protected static Logger loggerOpenSPCoopStatisticheOrarieError = null;
  161.     protected static Logger loggerOpenSPCoopStatisticheGiornaliere = null;
  162.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereError = null;
  163.     protected static Logger loggerOpenSPCoopStatisticheSettimanali = null;
  164.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliError = null;
  165.     protected static Logger loggerOpenSPCoopStatisticheMensili = null;
  166.     protected static Logger loggerOpenSPCoopStatisticheMensiliError = null;
  167.     /**  Logger log4j utilizzato per le statistiche */
  168.     protected static Logger loggerOpenSPCoopStatisticheOrarieSql = null;
  169.     protected static Logger loggerOpenSPCoopStatisticheOrarieSqlError = null;
  170.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereSql = null;
  171.     protected static Logger loggerOpenSPCoopStatisticheGiornaliereSqlError = null;
  172.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliSql = null;
  173.     protected static Logger loggerOpenSPCoopStatisticheSettimanaliSqlError = null;
  174.     protected static Logger loggerOpenSPCoopStatisticheMensiliSql = null;
  175.     protected static Logger loggerOpenSPCoopStatisticheMensiliSqlError = null;
  176.     /**  Logger log4j utilizzato per consegna contenuti */
  177.     protected static Logger loggerOpenSPCoopConsegnaContenuti = null;
  178.     protected static Logger loggerOpenSPCoopConsegnaContenutiError = null;
  179.     /**  Logger log4j utilizzato per consegna contenuti */
  180.     protected static Logger loggerOpenSPCoopConsegnaContenutiSql = null;
  181.     protected static Logger loggerOpenSPCoopConsegnaContenutiSqlError = null;
  182.     /**  Logger log4j utilizzato per i Plugins */
  183.     protected static Logger loggerOpenSPCoopPlugins = null;
  184.     protected static Logger loggerOpenSPCoopPluginsError = null;
  185.     /**  Logger log4j utilizzato per i Plugins (sql) */
  186.     protected static Logger loggerOpenSPCoopPluginsSql = null;
  187.     protected static Logger loggerOpenSPCoopPluginsSqlError = null;
  188.     /**  Logger log4j utilizzato per il gestore delle chiavi PDND */
  189.     protected static Logger loggerOpenSPCoopGestoreChiaviPDND = null;
  190.     protected static Logger loggerOpenSPCoopGestoreChiaviPDNDError = null;
  191.     /**  Logger log4j utilizzato per il gestore delle operazioni remote */
  192.     protected static Logger loggerOpenSPCoopGestoreOperazioniRemote = null;
  193.     protected static Logger loggerOpenSPCoopGestoreOperazioniRemoteError = null;
  194.     /** Appender personalizzati per i messaggi diagnostici di OpenSPCoop */
  195.     public static List<IDiagnosticProducer> loggerMsgDiagnosticoOpenSPCoopAppender = new ArrayList<>(); 
  196.     public static List<String> tipoMsgDiagnosticoOpenSPCoopAppender = new ArrayList<>();
  197.     /** Appender personalizzati per i tracciamenti di OpenSPCoop */
  198.     public static List<ITracciaProducer> loggerTracciamentoOpenSPCoopAppender = new ArrayList<>(); 
  199.     public static List<String> tipoTracciamentoOpenSPCoopAppender = new ArrayList<>();
  200.     /** Appender personalizzati per i dump applicativi di OpenSPCoop */
  201.     public static List<IDumpProducer> loggerDumpOpenSPCoopAppender = new ArrayList<>(); 
  202.     public static List<String> tipoDumpOpenSPCoopAppender = new ArrayList<>();
  203.     /** PdDContextSerializer */
  204.     private static IPdDContextSerializer pddContextSerializer = null;
  205.     /** LogDir */
  206.     private static List<File> logDirs;
  207.     public static List<File> getLogDirs() {
  208.         return logDirs;
  209.     }

  211.     public static boolean isLoggerOpenSPCoopConsoleStartupAgganciatoLog(){
  212.         return OpenSPCoop2Logger.loggerOpenSPCoopConsoleStartupAgganciatoLog;
  213.     }
  214.     
  215.     private static final String APP_NAME = "govway";
  216.     
  217.     private static List<String> filesCheck;
  218.     private static void initializeLogDirs(Properties p, boolean append){
  219.         
  220.         if(!append) {
  221.             logDirs = new ArrayList<>();
  222.             filesCheck = new ArrayList<>();
  223.         }
  224.         
  225.         Enumeration<?> en = p.keys();
  226.         while (en.hasMoreElements()) {
  227.             String key = (String) en.nextElement();
  228.             key = key.trim();
  229.             String value = p.getProperty(key);
  230.             value = value.trim();
  231.             if(key.endsWith(".fileName") || key.endsWith(".filePattern")) {
  232.                 File fTmp = new File(value);
  233.                 if(fTmp.getParentFile()!=null) {
  234.                     if(filesCheck.contains(fTmp.getParentFile().getAbsolutePath())==false) {
  235.                         logDirs.add(fTmp.getParentFile());
  236.                         filesCheck.add(fTmp.getParentFile().getAbsolutePath());
  237.                     }
  238.                 }
  239.             }
  240.         }
  241.         
  242.     }
  243.     
  244.     /**
  245.      * Il Metodo si occupa di inizializzare il Logger utilizzato da OpenSPCoop (file,DB scelti da govway.log4j2.properties)
  246.      *
  247.      * @param logConsole Log console
  248.      * @return true in caso di inizializzazione con successo, false altrimenti.
  249.      * 
  250.      */
  251.     public static boolean initializeLogConsole(Logger logConsole){
  252.         InputStream isOp2 = null;
  253.         InputStream isLogger = null;
  254.         try{
  255.             isOp2 = OpenSPCoop2Logger.class.getResourceAsStream("/govway.properties");
  256.             String confDir = null;
  257.             if(isOp2!=null){
  258.                 java.util.Properties op2Properties = new java.util.Properties();
  259.                 op2Properties.load(isOp2);
  260.                 confDir = op2Properties.getProperty("org.openspcoop2.pdd.confDirectory");
  261.             }
  262.             
  263.             java.util.Properties loggerProperties = new java.util.Properties();
  264.             isLogger = OpenSPCoop2Logger.class.getResourceAsStream("/govway.log4j2.properties");
  265.             if(isLogger!=null){
  266.                 loggerProperties.load(isLogger);
  267.             }
  268.             
  269.             // Cerco eventuale ridefinizione
  270.             CollectionProperties loggerPropertiesRidefinito =  
  271.                     PropertiesUtilities.searchLocalImplementation(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,LoggerWrapperFactory.getLogger(OpenSPCoop2Logger.class), 
  272.                             CostantiPdD.OPENSPCOOP2_LOGGER_PROPERTIES, CostantiPdD.OPENSPCOOP2_LOGGER_LOCAL_PATH, 
  273.                             confDir);
  274.             
  275.             if(loggerPropertiesRidefinito!=null && loggerPropertiesRidefinito.size()>0){
  276.                 Enumeration<?> ridefinito = loggerPropertiesRidefinito.keys();
  277.                 while (ridefinito.hasMoreElements()) {
  278.                     String key = (String) ridefinito.nextElement();
  279.                     String value = (String) loggerPropertiesRidefinito.get(key);
  280.                     if(loggerProperties.containsKey(key)){
  281.                         //Object o = 
  282.                         loggerProperties.remove(key);
  283.                     }
  284.                     loggerProperties.put(key, value);
  285.                     //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  286.                 }
  287.             }
  288.             
  289.             LoggerWrapperFactory.patchLoggers(loggerProperties,  
  290.                     org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  291.                     Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  292.             LoggerWrapperFactory.setLogConfiguration(loggerProperties);
  293.             initializeLogDirs(loggerProperties, false);
  294.             
  295.             return true;
  296.         }catch(Exception e){
  297.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop: "
  298.                     +e.getMessage(),e);
  299.             return false;
  300.         }finally{
  301.             try{
  302.                 if(isOp2!=null){
  303.                     isOp2.close();
  304.                 }
  305.             }catch(Exception eClose){
  306.                 // close
  307.             }
  308.             try{
  309.                 if(isLogger!=null){
  310.                     isLogger.close();
  311.                 }
  312.             }catch(Exception eClose){
  313.                 // close
  314.             }
  315.         }
  316.     }
  317.     
  318.     
  319.     public static boolean initialize(Logger logConsole,String rootDirectory,Properties objectProperties,
  320.             boolean allarmiEnabled){
  321.         return initialize(logConsole, rootDirectory, objectProperties, true,
  322.                 allarmiEnabled);
  323.     }
  324.     public static boolean initialize(Logger logConsole,String rootDirectory,Properties objectProperties, boolean loadExternalConfiguration,
  325.             boolean allarmiEnabled){
  326.         try{
  327.             
  328.             // Originale
  329.             java.util.Properties loggerProperties = new java.util.Properties();
  330.             java.io.File loggerFile = new java.io.File(rootDirectory+"govway.log4j2.properties");
  331.             if(!loggerFile .exists() ){
  332.                 loggerProperties.load(OpenSPCoop2Logger.class.getResourceAsStream("/govway.log4j2.properties"));
  333.             }else{
  334.                 FileInputStream fin = null;
  335.                 try{
  336.                     fin = new java.io.FileInputStream(loggerFile);
  337.                     loggerProperties.load(fin);
  338.                 }finally{
  339.                     try{
  340.                         if(fin!=null){
  341.                             fin.close();
  342.                         }
  343.                     }catch(Exception eClose){
  344.                         // close
  345.                     }
  346.                 }
  347.             }
  348.             
  349.             if(loadExternalConfiguration){
  350.             
  351.                 loadExternal(logConsole, CostantiPdD.OPENSPCOOP2_LOGGER_PROPERTIES ,CostantiPdD.OPENSPCOOP2_LOGGER_LOCAL_PATH, 
  352.                         rootDirectory, loggerProperties, objectProperties);
  353.                 
  354.             }
  355.             
  356.             
  357.             
  358.             LoggerWrapperFactory.patchLoggers(loggerProperties, 
  359.                     org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  360.                     Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  361.             
  362.             LoggerWrapperFactory.setLogConfiguration(loggerProperties);
  363.             initializeLogDirs(loggerProperties, false);
  364.             
  365.             // STARTUP CONSOLE
  366.             String tmp = loggerProperties.getProperty("logger.govway_startup.level");
  367.             if(tmp!=null){
  368.                 if(!tmp.equalsIgnoreCase("OFF")){
  369.                     OpenSPCoop2Logger.loggerOpenSPCoopConsoleStartupAgganciatoLog = true;
  370.                 }
  371.             }
  372.             
  373.             // TRACCIAMENTO
  374.             OpenSPCoop2Logger.loggerTracciamento = LoggerWrapperFactory.getLogger("govway.tracciamento");
  375.             if(OpenSPCoop2Logger.loggerTracciamento==null)
  376.                 throw new CoreException("Logger govway.tracciamento non trovato");
  377.             // Abilitazione log da Log4j
  378.             tmp = loggerProperties.getProperty("logger.govway_tracciamento.level");
  379.             if(tmp!=null){
  380.                 tmp = tmp.trim();
  381.                 if(tmp.equalsIgnoreCase("OFF")){
  382.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging delle tracce disabilitato da log4j (OFF).");
  383.                     OpenSPCoop2Logger.loggerTracciamentoAbilitato = false;
  384.                 }
  385.                 else
  386.                     OpenSPCoop2Logger.loggerTracciamentoAbilitato = true;
  387.             }
  388.             
  389.             // MESSAGGI DIAGNOSTICI
  390.             OpenSPCoop2Logger.loggerMsgDiagnostico = LoggerWrapperFactory.getLoggerImpl("govway.msgDiagnostico");
  391.             if(OpenSPCoop2Logger.loggerMsgDiagnostico==null)
  392.                 throw new CoreException("Logger govway.msgDiagnostico non trovato");
  393.             // Abilitazione log da Log4j
  394.             tmp = loggerProperties.getProperty("logger.govway_diagnostici.level");
  395.             if(tmp!=null){
  396.                 tmp = tmp.trim();
  397.                 if(tmp.equalsIgnoreCase("OFF")){
  398.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici disabilitato da log4j (OFF).");
  399.                     OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato = false;
  400.                 }else
  401.                     OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato = true;
  402.             }
  403.             
  404.             // MESSAGGI DIAGNOSTICI LEGGIBILI
  405.             OpenSPCoop2Logger.loggerOpenSPCoop2 = LoggerWrapperFactory.getLoggerImpl("govway.portaDiDominio");
  406.             if(OpenSPCoop2Logger.loggerOpenSPCoop2==null)
  407.                 throw new CoreException("Logger govway.portaDiDominio non trovato");
  408.             // Abilitazione log da Log4j
  409.             tmp = loggerProperties.getProperty("logger.govway_portaDiDominio.level");
  410.             if(tmp!=null){
  411.                 tmp = tmp.trim();
  412.                 if(tmp.equalsIgnoreCase("OFF")){
  413.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici 'readable' disabilitato da log4j (OFF).");
  414.                     OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato = false;
  415.                 }else
  416.                     OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato = true;
  417.             }
  418.             
  419.             // MESSAGGI DIAGNOSTICI DELL'INTEGRATION MANAGER
  420.             OpenSPCoop2Logger.loggerIntegrationManager = LoggerWrapperFactory.getLoggerImpl("govway.integrationManager");
  421.             if(OpenSPCoop2Logger.loggerIntegrationManager==null)
  422.                 throw new CoreException("Logger govway.integrationManager non trovato");
  423.             // Abilitazione log da Log4j
  424.             tmp = loggerProperties.getProperty("logger.govway_integrationManager.level");
  425.             if(tmp!=null){
  426.                 tmp = tmp.trim();
  427.                 if(tmp.equalsIgnoreCase("OFF")){
  428.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei messaggi diagnostici 'readable' per il servizio di IntegrationManager disabilitato da log4j (OFF).");
  429.                     OpenSPCoop2Logger.loggerIntegrationManagerAbilitato = false;
  430.                 }else
  431.                     OpenSPCoop2Logger.loggerIntegrationManagerAbilitato = true;
  432.             }
  433.             
  434.             // DUMP APPLICATIVO
  435.             OpenSPCoop2Logger.loggerDump = LoggerWrapperFactory.getLogger("govway.dump");
  436.             if(OpenSPCoop2Logger.loggerDump==null)
  437.                 throw new CoreException("Logger govway.dump non trovato");
  438.             // Abilitazione log da Log4j
  439.             tmp = loggerProperties.getProperty("logger.govway_dump.level");
  440.             if(tmp!=null){
  441.                 tmp = tmp.trim();
  442.                 if(tmp.equalsIgnoreCase("OFF")){
  443.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging dei contenuti applicativi (dump) disabilitato da log4j (OFF).");
  444.                     OpenSPCoop2Logger.loggerDumpAbilitato = false;
  445.                 }
  446.                 else
  447.                     OpenSPCoop2Logger.loggerDumpAbilitato = true;
  448.             }

  450.             // OPENSPCOOP CORE
  451.             OpenSPCoop2Logger.loggerOpenSPCoopCore = LoggerWrapperFactory.getLogger("govway.core");
  452.             if(OpenSPCoop2Logger.loggerOpenSPCoopCore==null)
  453.                 throw new CoreException("Logger govway.core non trovato");
  454.             
  455.             // TIMERS LOG
  456.             OpenSPCoop2Logger.loggerOpenSPCoopTimers = LoggerWrapperFactory.getLogger("govway.timers");
  457.             if(OpenSPCoop2Logger.loggerOpenSPCoopTimers==null)
  458.                 throw new CoreException("Logger govway.timers non trovato");
  459.             
  460.             // RESOURCES LOG
  461.             OpenSPCoop2Logger.loggerOpenSPCoopResources = LoggerWrapperFactory.getLogger("govway.resources");
  462.             if(OpenSPCoop2Logger.loggerOpenSPCoopResources==null)
  463.                 throw new CoreException("Logger govway.resources non trovato");
  464.             OpenSPCoop2Logger.loggerOpenSPCoopResourcesAsLoggerImpl = LoggerWrapperFactory.getLoggerImpl("govway.resources");
  465.             if(OpenSPCoop2Logger.loggerOpenSPCoopResourcesAsLoggerImpl==null)
  466.                 throw new CoreException("Logger(Impl) govway.resources non trovato");
  467.             
  468.             // CONFIGURAZIONE SISTEMA LOG
  469.             OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema = LoggerWrapperFactory.getLogger("govway.configurazioneSistema");
  470.             if(OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema==null)
  471.                 throw new CoreException("Logger govway.configurazioneSistema non trovato");
  472.             
  473.             // PROXY LOG
  474.             OpenSPCoop2Logger.loggerOpenSPCoopProxy = LoggerWrapperFactory.getLogger("govway.proxy");
  475.             if(OpenSPCoop2Logger.loggerOpenSPCoopProxy==null)
  476.                 throw new CoreException("Logger govway.proxy non trovato");
  477.             
  478.             // CONNETTORI LOG
  479.             OpenSPCoop2Logger.loggerOpenSPCoopConnettori = LoggerWrapperFactory.getLogger("govway.connettori");
  480.             if(OpenSPCoop2Logger.loggerOpenSPCoopConnettori==null)
  481.                 throw new CoreException("Logger govway.connettori non trovato");
  482.                         
  483.             // RAW DATA SERVIZIO PD LOG
  484.             OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD = LoggerWrapperFactory.getLogger("govway.dumpBinarioPD");
  485.             if(OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD==null)
  486.                 throw new CoreException("Logger govway.dumpBinarioPD non trovato");
  487.             
  488.             // RAW DATA SERVIZIO PD LOG
  489.             OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA = LoggerWrapperFactory.getLogger("govway.dumpBinarioPA");
  490.             if(OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA==null)
  491.                 throw new CoreException("Logger govway.dumpBinarioPA non trovato");
  492.             
  493.             // EVENTI LOG
  494.             OpenSPCoop2Logger.loggerOpenSPCoopEventi = LoggerWrapperFactory.getLogger("govway.eventi");
  495.             if(OpenSPCoop2Logger.loggerOpenSPCoopEventi==null)
  496.                 throw new CoreException("Logger govway.eventi non trovato");
  497.             
  498.             // TRANSAZIONI LOG
  499.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioni = LoggerWrapperFactory.getLogger("govway.transazioni");
  500.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioni==null)
  501.                 throw new CoreException("Logger govway.transazioni non trovato");
  502.             
  503.             // TRANSAZIONI LOG (ERROR)
  504.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError = LoggerWrapperFactory.getLogger("govway.transazioni.error");
  505.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError==null)
  506.                 throw new CoreException("Logger govway.transazioni.error non trovato");
  507.             
  508.             // TRANSAZIONI LOG (DEVNULL)
  509.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull = LoggerWrapperFactory.getLogger("govway.transazioni.devnull");
  510.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull==null)
  511.                 throw new CoreException("Logger govway.transazioni.devnull non trovato");
  512.             
  513.             // TRANSAZIONI SQL LOG
  514.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql = LoggerWrapperFactory.getLogger("govway.transazioni.sql");
  515.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql==null)
  516.                 throw new CoreException("Logger govway.transazioni.sql non trovato");
  517.             
  518.             // TRANSAZIONI SQL LOG (ERROR)
  519.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError = LoggerWrapperFactory.getLogger("govway.transazioni.sql.error");
  520.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError==null)
  521.                 throw new CoreException("Logger govway.transazioni.sql.error non trovato");
  522.             
  523.             // TRANSAZIONI STATEFUL LOG
  524.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful = LoggerWrapperFactory.getLogger("govway.transazioni.stateful");
  525.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful==null)
  526.                 throw new CoreException("Logger govway.transazioni.stateful non trovato");
  527.             
  528.             // TRANSAZIONI STATEFUL LOG (ERROR)
  529.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.error");
  530.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError==null)
  531.                 throw new CoreException("Logger govway.transazioni.stateful.error non trovato");
  532.             
  533.             // TRANSAZIONI STATEFUL SQL LOG
  534.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.sql");
  535.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql==null)
  536.                 throw new CoreException("Logger govway.transazioni.stateful.sql non trovato");
  537.             
  538.             // TRANSAZIONI STATEFUL SQL LOG (ERROR)
  539.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError = LoggerWrapperFactory.getLogger("govway.transazioni.stateful.sql.error");
  540.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError==null)
  541.                 throw new CoreException("Logger govway.transazioni.stateful.sql.error non trovato");
  542.             
  543.             // TRANSAZIONI SLOW LOG
  544.             OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog = LoggerWrapperFactory.getLogger("govway.transazioni.slowLog");
  545.             if(OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog==null)
  546.                 throw new CoreException("Logger govway.transazioni.slowLog non trovato");
  547.             
  548.             // EVENTI LOG (ERROR)
  549.             OpenSPCoop2Logger.loggerOpenSPCoopEventiError = LoggerWrapperFactory.getLogger("govway.eventi.error");
  550.             if(OpenSPCoop2Logger.loggerOpenSPCoopEventiError==null)
  551.                 throw new CoreException("Logger govway.eventi.error non trovato");
  552.             
  553.             // FILE SYSTEM RECOVERY LOG
  554.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem");
  555.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery==null)
  556.                 throw new CoreException("Logger govway.recoveryFileSystem non trovato");
  557.             
  558.             // FILE SYSTEM RECOVERY LOG (ERROR)
  559.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.error");
  560.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError==null)
  561.                 throw new CoreException("Logger govway.recoveryFileSystem.error non trovato");
  562.             
  563.             // FILE SYSTEM RECOVERY SQL LOG
  564.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.sql");
  565.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql==null)
  566.                 throw new CoreException("Logger govway.recoveryFileSystem.sql non trovato");
  567.             
  568.             // FILE SYSTEM RECOVERY SQL LOG (ERROR)
  569.             OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError = LoggerWrapperFactory.getLogger("govway.recoveryFileSystem.sql.error");
  570.             if(OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError==null)
  571.                 throw new CoreException("Logger govway.recoveryFileSystem.sql.error non trovato");
  572.             
  573.             // CONTROLLO TRAFFICO LOG
  574.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico = LoggerWrapperFactory.getLogger("govway.controlloTraffico");
  575.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico==null)
  576.                 throw new CoreException("Logger govway.controlloTraffico non trovato");
  577.             
  578.             // CONTROLLO TRAFFICO LOG (ERROR)
  579.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError = LoggerWrapperFactory.getLogger("govway.controlloTraffico.error");
  580.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError==null)
  581.                 throw new CoreException("Logger govway.controlloTraffico.error non trovato");
  582.             
  583.             // CONTROLLO TRAFFICO SQL LOG
  584.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql = LoggerWrapperFactory.getLogger("govway.controlloTraffico.sql");
  585.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql==null)
  586.                 throw new CoreException("Logger govway.controlloTraffico.sql non trovato");
  587.             
  588.             // CONTROLLO TRAFFICO SQL LOG (ERROR)
  589.             OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError = LoggerWrapperFactory.getLogger("govway.controlloTraffico.sql.error");
  590.             if(OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError==null)
  591.                 throw new CoreException("Logger govway.controlloTraffico.sql.error non trovato");
  592.             
  593.             if(allarmiEnabled) {
  594.             
  595.                 // ALLARMI LOG
  596.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmi = LoggerWrapperFactory.getLogger("govway.controlloAllarmi");
  597.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmi==null)
  598.                     throw new CoreException("Logger govway.controlloAllarmi non trovato");
  599.                 
  600.                 // ALLARMI LOG (ERROR)
  601.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.error");
  602.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError==null)
  603.                     throw new CoreException("Logger govway.controlloAllarmi.error non trovato");
  604.                 
  605.                 // ALLARMI SQL LOG
  606.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.sql");
  607.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql==null)
  608.                     throw new CoreException("Logger govway.controlloAllarmi.sql non trovato");
  609.                 
  610.                 // ALLARMI SQL LOG (ERROR)
  611.                 OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError = LoggerWrapperFactory.getLogger("govway.controlloAllarmi.sql.error");
  612.                 if(OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError==null)
  613.                     throw new CoreException("Logger govway.controlloAllarmi.sql.error non trovato");
  614.                 
  615.             }
  616.             
  617.             // STATISTICHE LOG 'Orarie'
  618.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione");
  619.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie==null)
  620.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  621.             
  622.             // STATISTICHE LOG (ERROR) 'Orarie'
  623.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.error");
  624.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError==null)
  625.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  626.             
  627.             // STATISTICHE SQL LOG 'Orarie'
  628.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.sql");
  629.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql==null)
  630.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  631.             
  632.             // STATISTICHE SQL LOG (ERROR) 'Orarie'
  633.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_orarie.generazione.sql.error");
  634.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError==null)
  635.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  636.                         
  637.             // STATISTICHE LOG 'Giornaliere'
  638.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione");
  639.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere==null)
  640.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  641.             
  642.             // STATISTICHE LOG (ERROR) 'Giornaliere'
  643.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.error");
  644.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError==null)
  645.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  646.             
  647.             // STATISTICHE SQL LOG 'Giornaliere'
  648.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.sql");
  649.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql==null)
  650.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  651.             
  652.             // STATISTICHE SQL LOG (ERROR) 'Giornaliere'
  653.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_giornaliere.generazione.sql.error");
  654.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError==null)
  655.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  656.             
  657.             // STATISTICHE LOG 'Settimanali'
  658.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione");
  659.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali==null)
  660.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  661.             
  662.             // STATISTICHE LOG (ERROR) 'Settimanali'
  663.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.error");
  664.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError==null)
  665.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  666.             
  667.             // STATISTICHE SQL LOG 'Settimanali'
  668.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.sql");
  669.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql==null)
  670.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  671.             
  672.             // STATISTICHE SQL LOG (ERROR) 'Settimanali'
  673.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_settimanali.generazione.sql.error");
  674.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError==null)
  675.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  676.                 
  677.             // STATISTICHE LOG 'Mensili'
  678.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione");
  679.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili==null)
  680.                 throw new CoreException("Logger govway.statistiche.generazione non trovato");
  681.             
  682.             // STATISTICHE LOG (ERROR) 'Mensili'
  683.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.error");
  684.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError==null)
  685.                 throw new CoreException("Logger govway.statistiche.generazione.error non trovato");
  686.             
  687.             // STATISTICHE SQL LOG 'Mensili'
  688.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.sql");
  689.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql==null)
  690.                 throw new CoreException("Logger govway.statistiche.generazione.sql non trovato");
  691.             
  692.             // STATISTICHE SQL LOG (ERROR) 'Mensili'
  693.             OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError = LoggerWrapperFactory.getLogger("govway.statistiche_mensili.generazione.sql.error");
  694.             if(OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError==null)
  695.                 throw new CoreException("Logger govway.statistiche.generazione.sql.error non trovato");
  696.                 
  697.             // CONSEGNA_CONTENUTI LOG
  698.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti = LoggerWrapperFactory.getLogger("govway.consegna_messaggi");
  699.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti==null)
  700.                 throw new CoreException("Logger govway.consegna_messaggi non trovato");
  701.             
  702.             // CONSEGNA_CONTENUTI LOG (ERROR)
  703.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.error");
  704.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError==null)
  705.                 throw new CoreException("Logger govway.consegna_messaggi.error non trovato");
  706.             
  707.             // CONSEGNA_CONTENUTI SQL LOG
  708.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.sql");
  709.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql==null)
  710.                 throw new CoreException("Logger govway.consegna_messaggi.sql non trovato");
  711.             
  712.             // CONSEGNA_CONTENUTI SQL LOG (ERROR)
  713.             OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError = LoggerWrapperFactory.getLogger("govway.consegna_messaggi.sql.error");
  714.             if(OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError==null)
  715.                 throw new CoreException("Logger govway.consegna_messaggi.sql.error non trovato");

  717.             // PLUGINS LOG
  718.             OpenSPCoop2Logger.loggerOpenSPCoopPlugins = LoggerWrapperFactory.getLogger("govway.plugins");
  719.             if(OpenSPCoop2Logger.loggerOpenSPCoopPlugins==null)
  720.                 throw new CoreException("Logger govway.plugins non trovato");
  721.             
  722.             // PLUGINS LOG (ERROR)
  723.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsError = LoggerWrapperFactory.getLogger("govway.plugins.error");
  724.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsError==null)
  725.                 throw new CoreException("Logger govway.plugins.error non trovato");
  726.             
  727.             // PLUGINS SQL LOG
  728.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql = LoggerWrapperFactory.getLogger("govway.plugins.sql");
  729.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql==null)
  730.                 throw new CoreException("Logger govway.plugins.sql non trovato");
  731.             
  732.             // PLUGINS SQL LOG (ERROR)
  733.             OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError = LoggerWrapperFactory.getLogger("govway.plugins.sql.error");
  734.             if(OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError==null)
  735.                 throw new CoreException("Logger govway.plugins.sql.error non trovato");
  736.             
  737.             // GESTORE CHIAVI PDND LOG
  738.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND = LoggerWrapperFactory.getLogger("govway.gestoreChiaviPDND");
  739.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND==null)
  740.                 throw new CoreException("Logger govway.gestoreChiaviPDND non trovato");
  741.             
  742.             // GESTORE CHIAVI PDND LOG (ERROR)
  743.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError = LoggerWrapperFactory.getLogger("govway.gestoreChiaviPDND.error");
  744.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError==null)
  745.                 throw new CoreException("Logger govway.gestoreChiaviPDND.error non trovato");
  746.             
  747.             // GESTORE OPERAZIONI REMOTE LOG
  748.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote = LoggerWrapperFactory.getLogger("govway.gestoreOperazioniRemote");
  749.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote==null)
  750.                 throw new CoreException("Logger govway.gestoreOperazioniRemote non trovato");
  751.             
  752.             // GESTORE OPERAZIONI REMOTE LOG (ERROR)
  753.             OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError = LoggerWrapperFactory.getLogger("govway.gestoreOperazioniRemote.error");
  754.             if(OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError==null)
  755.                 throw new CoreException("Logger govway.gestoreOperazioniRemote.error non trovato");
  756.             
  757.             // CONSOLE
  758.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging correttamente inizializzato.");
  759.             
  760.             // PddContextSerializer
  761.             OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  762.             String pddContextSerializerClass = propertiesReader.getPddContextSerializer();
  763.             if(pddContextSerializerClass!=null && !CostantiConfigurazione.NONE.equals(pddContextSerializerClass)){
  764.                 try{
  765.                     OpenSPCoop2Logger.pddContextSerializer = (IPdDContextSerializer) Loader.getInstance().newInstance(pddContextSerializerClass);
  766.                 }catch(Exception e){
  767.                     throw new CoreException("Inizializzione IPdDContextSerializer non riuscita ["+pddContextSerializerClass+"]:"+e.getMessage(),e);
  768.                 }
  769.             }
  770.             
  771.             return true;
  772.         }catch(Exception e){
  773.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop: "
  774.                     +e.getMessage(),e);
  775.             return false;
  776.         }
  777.     }
  778.     
  779.     private static void loadExternal(Logger logConsole, String loggerProperty, String loggerPath, String rootDirectory,
  780.             java.util.Properties loggerProperties, Properties objectProperties) {
  781.             
  782.         // File Local Implementation
  783.         CollectionProperties loggerPropertiesRidefinito =  
  784.             PropertiesUtilities.searchLocalImplementation(CostantiPdD.OPENSPCOOP2_LOCAL_HOME,logConsole, loggerProperty ,loggerPath, rootDirectory);
  785.         if(loggerPropertiesRidefinito!=null && loggerPropertiesRidefinito.size()>0){
  786.             Enumeration<?> ridefinito = loggerPropertiesRidefinito.keys();
  787.             while (ridefinito.hasMoreElements()) {
  788.                 String key = (String) ridefinito.nextElement();
  789.                 String value = loggerPropertiesRidefinito.get(key);
  790.                 if(loggerProperties.containsKey(key)){
  791.                     //Object o = 
  792.                     loggerProperties.remove(key);
  793.                 }
  794.                 loggerProperties.put(key, value);
  795.                 //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  796.             }
  797.         }
  798.         
  799.         // File Object Implementation
  800.         if(objectProperties!=null && objectProperties.size()>0){
  801.             Enumeration<?> ridefinito = objectProperties.keys();
  802.             while (ridefinito.hasMoreElements()) {
  803.                 String key = (String) ridefinito.nextElement();
  804.                 String value = (String) objectProperties.get(key);
  805.                 if(loggerProperties.containsKey(key)){
  806.                     //Object o = 
  807.                     loggerProperties.remove(key);
  808.                 }
  809.                 loggerProperties.put(key, value);
  810.                 //System.out.println("CHECK NUOVO VALORE: "+loggerProperties.get(key));
  811.             }
  812.         }

  814.     }
  815.     
  816.     public static boolean initializeProtocolLogger(Logger logConsole, boolean loadExternalConfiguration,String rootDirectory,
  817.             Properties objectProperties) {
  818.         
  819.         try{
  820.         
  821.             ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  822.             Enumeration<String> protocolNames = protocolFactoryManager.getProtocolNames();
  823.             while (protocolNames.hasMoreElements()) {
  824.                 String protocol = (String) protocolNames.nextElement();
  825.                 if(protocolFactoryManager.isSupportedProtocolLogger(protocol)) {
  826.                     
  827.                     java.util.Properties loggerPropertiesProtocolAdjunct = null;
  828.                     InputStream isLoggerProtocol = OpenSPCoop2Logger.class.getResourceAsStream("/govway.protocolAdjunct.log4j2.properties");
  829.                     if(isLoggerProtocol!=null){
  830.                         String content = Utilities.getAsString(isLoggerProtocol, Charset.UTF_8.getValue());
  831.                         if(content!=null) {
  832.                             content = content.replaceAll(CostantiPdD.OPENSPCOOP2_LOGGER_PROTOCOL_ID_PROTOCOLLO, protocol);
  833.                             loggerPropertiesProtocolAdjunct = new java.util.Properties();
  834.                             StringReader sr = new StringReader(content);
  835.                             loggerPropertiesProtocolAdjunct.load(sr);
  836.                             sr.close();
  837.                         }
  838.                     }
  839.                     if(loadExternalConfiguration){
  840.                         
  841.                         loadExternal(logConsole, CostantiPdD.getOpenspcoop2LoggerProtocolProperties(protocol),
  842.                                 CostantiPdD.getOpenspcoop2LoggerProtocolLocalPath(protocol) ,
  843.                                 rootDirectory, loggerPropertiesProtocolAdjunct, objectProperties);
  844.                         
  845.                     }
  846.                     logConsole.info("Protocol '"+protocol+"': Log4j config append");
  847.                     if(loggerPropertiesProtocolAdjunct!=null) {
  848.                         LoggerWrapperFactory.patchLoggers(loggerPropertiesProtocolAdjunct,  
  849.                                 org.openspcoop2.utils.Costanti.ENV_LOG_GOVWAY,
  850.                                 Map.of(org.openspcoop2.utils.Costanti.VAR_LOGGER_APPNAME, APP_NAME));
  851.                         LoggerWrapperFactory.setLogConfiguration(loggerPropertiesProtocolAdjunct,true);
  852.                         initializeLogDirs(loggerPropertiesProtocolAdjunct, true);
  853.                     }
  854.                     
  855.                     Logger log = LoggerWrapperFactory.getLogger(CostantiPdD.getOpenspcoop2LoggerFactoryName(protocol));
  856.                     protocolFactoryManager.getProtocolFactoryByName(protocol).initProtocolLogger(log);
  857.                     log.info("Inizializzazione completata");
  858.                     
  859.                 }
  860.             }
  861.             
  862.             return true;
  863.             
  864.         }catch(Exception e){
  865.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione del sistema di logging di OpenSPCoop per i protocolli: "
  866.                     +e.getMessage(),e);
  867.             return false;
  868.         }
  869.     }

  871.     /**
  872.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei msg diagnostici senza passare da log4j
  873.      * @param msgDiagConfig Configurazione
  874.      * @return true in caso di inizializzazione con successo, false altrimenti.
  875.      */
  876.     public static boolean initializeMsgDiagnosticiOpenSPCoopAppender(MessaggiDiagnostici msgDiagConfig){
  877.         try{
  878.             // Inizializzazione msg diagnostici appender personalizzati
  879.             if(msgDiagConfig!=null){
  880.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  881.                 for(int i=0; i< msgDiagConfig.sizeOpenspcoopAppenderList(); i++){

  883.                     // MsgDiagAppenderClass
  884.                     String msgDiagAppenderClass = prop.getMsgDiagnosticoOpenSPCoopAppender(msgDiagConfig.getOpenspcoopAppender(i).getTipo());
  885.                     if(msgDiagAppenderClass == null){
  886.                         throw new CoreException("Riscontrato errore durante il caricamento del msg diagnostico appender ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  887.                     }

  889.                     // Carico appender richiesto
  890.                     IDiagnosticProducer appender = null;
  891.                     try{
  892.                         appender = (IDiagnosticProducer) Loader.getInstance().newInstance(msgDiagAppenderClass);
  893.                         appender.initializeAppender(msgDiagConfig.getOpenspcoopAppender(i));
  894.                     }catch(ClassNotFoundException e){
  895.                         throw new CoreException("Riscontrato errore durante il caricamento del msg diagnostico appender specificato ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  896.                     }catch(Exception e){
  897.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del msg diagnostico appender specificato ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  898.                     }
  899.                     
  900.                     // Aggiungo agli appender registrati
  901.                     OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender.add(appender);
  902.                     OpenSPCoop2Logger.tipoMsgDiagnosticoOpenSPCoopAppender.add(msgDiagConfig.getOpenspcoopAppender(i).getTipo());
  903.                     
  904.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: MsgDiagnosticoOpenSPCoopAppender di tipo ["+msgDiagConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  905.                     
  906.                 }
  907.             }
  908.             return true;
  909.         }catch(Exception e){
  910.             // Azzero gli appender personalizzati
  911.             OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender.clear(); 
  912.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per msg diagnostici: "
  913.                     +e.getMessage());
  914.             return false;
  915.         }
  916.     }

  918.     
  919.     /**
  920.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei tracciamenti senza passare da log4j
  921.      * @param tracciamentoConfig Configurazione
  922.      * @return true in caso di inizializzazione con successo, false altrimenti.
  923.      */
  924.     public static boolean initializeTracciamentoOpenSPCoopAppender(org.openspcoop2.core.config.Tracciamento tracciamentoConfig){
  925.         try{
  926.             // Inizializzazione tracciamento appender personalizzati
  927.             if(tracciamentoConfig!=null){
  928.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  929.                 for(int i=0; i< tracciamentoConfig.sizeOpenspcoopAppenderList(); i++){
  930.                     
  931.                     // Tracciamento appender class
  932.                     String tracciamentoAppenderClass = prop.getTracciamentoOpenSPCoopAppender(tracciamentoConfig.getOpenspcoopAppender(i).getTipo());
  933.                     if(tracciamentoAppenderClass == null){
  934.                         throw new CoreException("Riscontrato errore durante il caricamento del tracciamento appender ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  935.                     }

  937.                     // Carico appender richiesto
  938.                     ITracciaProducer appender = null;
  939.                     try{
  940.                         appender = (ITracciaProducer) Loader.getInstance().newInstance(tracciamentoAppenderClass);
  941.                         appender.initializeAppender(tracciamentoConfig.getOpenspcoopAppender(i));
  942.                     }catch(ClassNotFoundException e){
  943.                         throw new CoreException("Riscontrato errore durante il caricamento del tracciamento appender specificato ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  944.                     }catch(Exception e){
  945.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del tracciamento appender specificato ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  946.                     }
  947.                     
  948.                     // Aggiungo agli appender registrati
  949.                     OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender.add(appender);
  950.                     OpenSPCoop2Logger.tipoTracciamentoOpenSPCoopAppender.add(tracciamentoConfig.getOpenspcoopAppender(i).getTipo());
  951.                     
  952.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: TracciamentoOpenSPCoopAppender di tipo ["+tracciamentoConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  953.                     
  954.                 }
  955.             }
  956.             return true;
  957.         }catch(Exception e){
  958.             // Azzero gli appender personalizzati
  959.             OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender.clear(); 
  960.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per il tracciamento: "
  961.                     +e.getMessage());
  962.             return false;
  963.         }
  964.     }
  965.     
  966.     /**
  967.      * Il Metodo si occupa di inizializzare gli appender personalizzati di OpenSPCoop che permettono di effettuare log dei dump applicativi senza passare da log4j
  968.      * @param dumpConfig Configurazione
  969.      * @return true in caso di inizializzazione con successo, false altrimenti.
  970.      */
  971.     public static boolean initializeDumpOpenSPCoopAppender(org.openspcoop2.core.config.Dump dumpConfig){
  972.         try{
  973.             // Inizializzazione dump appender personalizzati
  974.             if(dumpConfig!=null){
  975.                 ClassNameProperties prop = ClassNameProperties.getInstance();
  976.                 for(int i=0; i< dumpConfig.sizeOpenspcoopAppenderList(); i++){
  977.                     
  978.                     // Dump Appender class
  979.                     String dumpAppenderClass = prop.getDumpOpenSPCoopAppender(dumpConfig.getOpenspcoopAppender(i).getTipo());
  980.                     if(dumpAppenderClass == null){
  981.                         throw new CoreException("Riscontrato errore durante il caricamento del dump appender ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: appender non registrato.");
  982.                     }

  984.                     // Carico appender richiesto
  985.                     IDumpProducer appender = null;
  986.                     try{
  987.                         appender = (IDumpProducer) Loader.getInstance().newInstance(dumpAppenderClass);
  988.                         appender.initializeAppender(dumpConfig.getOpenspcoopAppender(i));
  989.                     }catch(ClassNotFoundException e){
  990.                         throw new CoreException("Riscontrato errore durante il caricamento del dump appender specificato ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  991.                     }catch(Exception e){
  992.                         throw new CoreException("Riscontrato errore durante l'inizializzazione del dump appender specificato ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"]: "+e.getMessage());
  993.                     }
  994.                     
  995.                     // Aggiungo agli appender registrati
  996.                     OpenSPCoop2Logger.loggerDumpOpenSPCoopAppender.add(appender);
  997.                     OpenSPCoop2Logger.tipoDumpOpenSPCoopAppender.add(dumpConfig.getOpenspcoopAppender(i).getTipo());
  998.                     
  999.                     OpenSPCoop2Logger.loggerOpenSPCoopConsole.info("Sistema di logging: DumpOpenSPCoopAppender di tipo ["+dumpConfig.getOpenspcoopAppender(i).getTipo()+"] correttamente inizializzato.");
  1000.                 }
  1001.             }
  1002.             return true;
  1003.         }catch(Exception e){
  1004.             // Azzero gli appender personalizzati
  1005.             OpenSPCoop2Logger.loggerDumpOpenSPCoopAppender.clear(); 
  1006.             OpenSPCoop2Logger.loggerOpenSPCoopConsole.error("Riscontrato errore durante l'inizializzazione degli appender personalizzati per il dump applicativo: "
  1007.                     +e.getMessage());
  1008.             return false;
  1009.         }
  1010.     }
  1011.     

  1013.     public static String humanReadable(MsgDiagnostico msgDiag,IProtocolFactory<?> protocolFactory){
  1014.         return humanReadable(msgDiag, null, null, 
  1015.                 null, false, null, null, null, protocolFactory);
  1016.     }
  1017.     /**
  1018.      * Trasforma il messaggio diagnostico in una forma leggibile.
  1019.      * 
  1020.      * @param msgDiag MSg diagnostico
  1021.      * @param idCorrelazioneApplicativa Identificativo di correlazione applicativa
  1022.      * @param porta Identificativo della Porta
  1023.      * @param delegata Indicazione se siamo in un contesto di porta delegata o applicativa
  1024.      * @param fruitore Fruitore
  1025.      * @param servizio Servizio
  1026.      * @param servizioApplicativo Servizio Applicativo
  1027.      * @return messaggio diagnostico in una forma leggibile.
  1028.      */
  1029.     public static String humanReadable(MsgDiagnostico msgDiag,String idCorrelazioneApplicativa,String idCorrelazioneApplicativaRisposta,
  1030.             String porta,boolean delegata,IDSoggetto fruitore,IDServizio servizio,String servizioApplicativo,IProtocolFactory<?> protocolFactory){

  1032.         String protocol = null;
  1033.         if(protocolFactory!=null) {
  1034.             protocol = protocolFactory.getProtocol();
  1035.         }
  1036.         
  1037.         boolean formatValues = false;
  1038.         if(protocol!=null) {
  1039.             formatValues = OpenSPCoop2Properties.getInstance().isRegistrazioneDiagnosticaFile_intestazione_formatValues();
  1040.         }
  1041.         
  1042.         Date gdo = msgDiag.getGdo();
  1043.         String idPorta = msgDiag.getIdSoggetto().getCodicePorta()+"."+msgDiag.getIdSoggetto().toString();
  1044.         if(formatValues) {
  1045.             try {
  1046.                 idPorta = NamingUtils.getLabelSoggetto(protocol, msgDiag.getIdSoggetto());
  1047.             }catch(Exception e) {}
  1048.         }
  1049.         String idFunzione = msgDiag.getIdFunzione();
  1050.         int valueLivello = msgDiag.getSeverita();
  1051.         String text = msgDiag.getMessaggio();
  1052.         String idBusta = msgDiag.getIdBusta();
  1053.         String codiceDiagnostico = msgDiag.getCodice();
  1054.         
  1055.         StringBuilder showMsg = new StringBuilder();
  1056.         
  1057.         if(protocol!=null) {
  1058.             String labelP = protocol;
  1059.             if(formatValues) {
  1060.                 try {
  1061.                     labelP = NamingUtils.getLabelProtocollo(protocol);
  1062.                 }catch(Exception e) {}
  1063.             }
  1064.             showMsg.append("<").append(labelP).append(">");
  1065.         }
  1066.         
  1067.         if(msgDiag.getIdTransazione()!=null) {
  1068.             if(showMsg.length()>0){
  1069.                 showMsg.append(" ");
  1070.             }
  1071.             showMsg.append(msgDiag.getIdTransazione());
  1072.         }
  1073.         
  1074.         if(OpenSPCoop2Logger.pddContextSerializer!=null){
  1075.             Map<String, String> contextSerializerParameters = OpenSPCoop2Logger.pddContextSerializer.getLoggerKeywords();
  1076.             if(contextSerializerParameters!=null && contextSerializerParameters.size()>0){
  1077.                 for (String keyword : contextSerializerParameters.keySet()) {
  1078.                     if(msgDiag.getPropertiesNames()!=null){
  1079.                         String [] propertyNames = msgDiag.getPropertiesNames();
  1080.                         for (int i = 0; i < propertyNames.length; i++) {
  1081.                             if(keyword.equals(propertyNames[i])){
  1082.                                 if(showMsg.length()>0){
  1083.                                     showMsg.append(" ");
  1084.                                 }
  1085.                                 showMsg.append(propertyNames[i]+":");
  1086.                                 showMsg.append(msgDiag.getProperty(propertyNames[i]));
  1087.                             }
  1088.                         }
  1089.                     }
  1090.                 }
  1091.             }
  1092.         }
  1093.         
  1094.         if(codiceDiagnostico!=null){
  1095.             if(showMsg.length()>0){
  1096.                 showMsg.append(" ");
  1097.             }
  1098.             showMsg.append(codiceDiagnostico);
  1099.             showMsg.append(" ");
  1100.         }
  1101.         showMsg.append(idPorta);
  1102.         showMsg.append(" ");
  1103.         showMsg.append(idFunzione);
  1104.         showMsg.append(" <");
  1105.         showMsg.append(DateBuilder.getDate_Format(gdo));
  1106.         showMsg.append("> ");
  1107.         showMsg.append("(");
  1108.         showMsg.append((LogLevels.toLog4J(valueLivello)).toString());
  1109.         showMsg.append(")");
  1110.         if(idBusta!=null){
  1111.             showMsg.append(" ID:");
  1112.             showMsg.append(idBusta);
  1113.         }
  1114.         if(idCorrelazioneApplicativa!=null){
  1115.             showMsg.append(" IDApplicativo:");
  1116.             showMsg.append(idCorrelazioneApplicativa);
  1117.         }
  1118.         if(idCorrelazioneApplicativaRisposta!=null){
  1119.             showMsg.append(" IDApplicativoRisposta:");
  1120.             showMsg.append(idCorrelazioneApplicativaRisposta);
  1121.         }
  1122.         if(porta!=null && !"".equals(porta)) {
  1123.             String labelPorta = porta;
  1124.             // E' meglio vedere esattamente il nome della PD/PA. O in alternativa levarlo proprio. Senno' le PD/PA specific come si visualizzano??
  1125. //          if(formatValues) {
  1126. //              try {
  1127. //                  org.openspcoop2.protocol.utils.PorteNamingUtils utils = new org.openspcoop2.protocol.utils.PorteNamingUtils(protocolFactory);
  1128. //                  if(delegata) {
  1129. //                      labelPorta = utils.normalizePD(porta);
  1130. //                  }
  1131. //                  else {
  1132. //                      labelPorta = utils.normalizePA(porta);
  1133. //                  }
  1134. //              }catch(Exception e) {}
  1135. //          }
  1136.             if(delegata) {
  1137.                 showMsg.append(" OUT:"+labelPorta);
  1138.             }else {
  1139.                 showMsg.append(" IN:"+labelPorta);
  1140.             }
  1141.         }
  1142.         if(servizioApplicativo!=null){
  1143.             if(formatValues) {
  1144.                 if(delegata && !CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(servizioApplicativo)) {
  1145.                     showMsg.append(" Applicativo:"+servizioApplicativo);
  1146.                 }
  1147.             }
  1148.             else {
  1149.                 showMsg.append(" SA:"+servizioApplicativo);
  1150.             }
  1151.         }
  1152.         if( fruitore!=null && fruitore.getNome()!=null ){
  1153.             showMsg.append(" FR:");
  1154.             String fruitoreLabel = fruitore.toString();
  1155.             if(formatValues) {
  1156.                 try {
  1157.                     fruitoreLabel = NamingUtils.getLabelSoggetto(protocol, fruitore);
  1158.                 }catch(Exception e) {}
  1159.             }
  1160.             showMsg.append(fruitoreLabel);
  1161.         }
  1162.         if( fruitore!=null && servizio!=null)
  1163.             showMsg.append(" -> ");
  1164.         if( servizio!=null ){
  1165.             if(servizio.getNome()!=null){
  1166.                 showMsg.append(" S:");
  1167.                 String servizioLabel = null;
  1168.                 try{
  1169.                     servizioLabel = IDServizioFactory.getInstance().getUriFromIDServizio(servizio);
  1170.                 }catch(Exception e){
  1171.                     servizioLabel = servizio.toString(false);
  1172.                 }
  1173.                 if(formatValues) {
  1174.                     try {
  1175.                         servizioLabel = NamingUtils.getLabelAccordoServizioParteSpecifica(protocol, servizio);
  1176.                     }catch(Exception e) {}
  1177.                 }
  1178.                 showMsg.append(servizioLabel);
  1179.             }else if(servizio.getSoggettoErogatore()!=null){
  1180.                 showMsg.append(" ER:");
  1181.                 String erogatoreLabel = servizio.getSoggettoErogatore().toString();
  1182.                 if(formatValues) {
  1183.                     try {
  1184.                         erogatoreLabel = NamingUtils.getLabelSoggetto(protocol, servizio.getSoggettoErogatore());
  1185.                     }catch(Exception e) {}
  1186.                 }
  1187.                 showMsg.append(erogatoreLabel);
  1188.             }
  1189.             
  1190.             if(servizio.getAzione()!=null){
  1191.                 showMsg.append(" A:");
  1192.                 showMsg.append(servizio.getAzione());
  1193.             }
  1194.         }
  1195.                 
  1196.         showMsg.append("\n");
  1197.         showMsg.append(text);
  1198.         showMsg.append("\n");

  1200.         return showMsg.toString();


  1203.     }

  1205.     public static Logger getLoggerOpenSPCoopConsole() {
  1206.         return OpenSPCoop2Logger.loggerOpenSPCoopConsole;
  1207.     }

  1209.     public static Logger getLoggerOpenSPCoopCore() {
  1210.         return OpenSPCoop2Logger.loggerOpenSPCoopCore;
  1211.     }
  1212.     
  1213.     public static Logger getLoggerOpenSPCoopTimers() {
  1214.         return OpenSPCoop2Logger.loggerOpenSPCoopTimers;
  1215.     }
  1216.     
  1217.     public static Logger getLoggerOpenSPCoopResources() {
  1218.         return OpenSPCoop2Logger.loggerOpenSPCoopResources;
  1219.     }

  1221.     public static Logger getLoggerOpenSPCoopConfigurazioneSistema() {
  1222.         return OpenSPCoop2Logger.loggerOpenSPCoopConfigurazioneSistema;
  1223.     }

  1225.     public static Logger getLoggerOpenSPCoopProxy() {
  1226.         return OpenSPCoop2Logger.loggerOpenSPCoopProxy;
  1227.     }
  1228.     
  1229.     public static Logger getLoggerOpenSPCoopConnettori() {
  1230.         return OpenSPCoop2Logger.loggerOpenSPCoopConnettori;
  1231.     }
  1232.     
  1233.     public static Logger getLoggerOpenSPCoopDumpBinarioPD() {
  1234.         return OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPD;
  1235.     }
  1236.     
  1237.     public static Logger getLoggerOpenSPCoopDumpBinarioPA() {
  1238.         return OpenSPCoop2Logger.loggerOpenSPCoopDumpBinarioPA;
  1239.     }
  1240.     
  1241.     public static Logger getLoggerOpenSPCoopTransazioni(boolean debug) {
  1242.         if(debug) {
  1243.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioni;
  1244.         }
  1245.         else {
  1246.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniError;
  1247.         }
  1248.     }
  1249.     public static Logger getLoggerOpenSPCoopTransazioniDevNull() {
  1250.         return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniDevNull;
  1251.     }
  1252.     
  1253.     public static Logger getLoggerOpenSPCoopTransazioniSql(boolean debug) {
  1254.         if(debug) {
  1255.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSql;
  1256.         }
  1257.         else {
  1258.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSqlError;
  1259.         }
  1260.     }
  1261.     
  1262.     public static Logger getLoggerOpenSPCoopTransazioniStateful(boolean debug) {
  1263.         if(debug) {
  1264.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStateful;
  1265.         }
  1266.         else {
  1267.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulError;
  1268.         }
  1269.     }
  1270.     
  1271.     public static Logger getLoggerOpenSPCoopTransazioniStatefulSql(boolean debug) {
  1272.         if(debug) {
  1273.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSql;
  1274.         }
  1275.         else {
  1276.             return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniStatefulSqlError;
  1277.         }
  1278.     }
  1279.     
  1280.     public static Logger getLoggerOpenSPCoopTransazioniSlowLog() {
  1281.         return OpenSPCoop2Logger.loggerOpenSPCoopTransazioniSlowLog;
  1282.     }
  1283.     
  1284.     public static Logger getLoggerOpenSPCoopEventi(boolean debug) {
  1285.         if(debug) {
  1286.             return OpenSPCoop2Logger.loggerOpenSPCoopEventi;
  1287.         }
  1288.         else {
  1289.             return OpenSPCoop2Logger.loggerOpenSPCoopEventiError;
  1290.         }
  1291.     }
  1292.     
  1293.     public static Logger getLoggerOpenSPCoopFileSystemRecovery(boolean debug) {
  1294.         if(debug) {
  1295.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecovery;
  1296.         }
  1297.         else {
  1298.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoveryError;
  1299.         }
  1300.     }
  1301.     
  1302.     public static Logger getLoggerOpenSPCoopFileSystemRecoverySql(boolean debug) {
  1303.         if(debug) {
  1304.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySql;
  1305.         }
  1306.         else {
  1307.             return OpenSPCoop2Logger.loggerOpenSPCoopFileSystemRecoverySqlError;
  1308.         }
  1309.     }
  1310.     
  1311.     public static Logger getLoggerOpenSPCoopControlloTraffico(boolean debug) {
  1312.         if(debug) {
  1313.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTraffico;
  1314.         }
  1315.         else {
  1316.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoError;
  1317.         }
  1318.     }
  1319.     
  1320.     public static Logger getLoggerOpenSPCoopControlloTrafficoSql(boolean debug) {
  1321.         if(debug) {
  1322.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSql;
  1323.         }
  1324.         else {
  1325.             return OpenSPCoop2Logger.loggerOpenSPCoopControlloTrafficoSqlError;
  1326.         }
  1327.     }
  1328.     
  1329.     public static Logger getLoggerOpenSPCoopAllarmi(boolean debug) {
  1330.         if(debug) {
  1331.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmi;
  1332.         }
  1333.         else {
  1334.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiError;
  1335.         }
  1336.     }
  1337.     
  1338.     public static Logger getLoggerOpenSPCoopAllarmiSql(boolean debug) {
  1339.         if(debug) {
  1340.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSql;
  1341.         }
  1342.         else {
  1343.             return OpenSPCoop2Logger.loggerOpenSPCoopAllarmiSqlError;
  1344.         }
  1345.     }
  1346.     
  1347.     public static Logger getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico tipoStatistica, boolean debug) {
  1348.         if(debug) {
  1349.             switch (tipoStatistica) {
  1350.             case STATISTICHE_ORARIE:
  1351.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarie;
  1352.             case STATISTICHE_GIORNALIERE:
  1353.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliere;
  1354.             case STATISTICHE_SETTIMANALI:
  1355.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanali;
  1356.             case STATISTICHE_MENSILI:
  1357.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensili;
  1358.             }
  1359.         }
  1360.         else {
  1361.             switch (tipoStatistica) {
  1362.             case STATISTICHE_ORARIE:
  1363.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieError;
  1364.             case STATISTICHE_GIORNALIERE:
  1365.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereError;
  1366.             case STATISTICHE_SETTIMANALI:
  1367.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliError;
  1368.             case STATISTICHE_MENSILI:
  1369.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliError;
  1370.             }
  1371.         }
  1372.         return null;
  1373.     }
  1374.     
  1375.     public static Logger getLoggerOpenSPCoopStatisticheSql(TipoIntervalloStatistico tipoStatistica, boolean debug) {
  1376.         if(debug) {
  1377.             switch (tipoStatistica) {
  1378.             case STATISTICHE_ORARIE:
  1379.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSql;
  1380.             case STATISTICHE_GIORNALIERE:
  1381.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSql;
  1382.             case STATISTICHE_SETTIMANALI:
  1383.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSql;
  1384.             case STATISTICHE_MENSILI:
  1385.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSql;
  1386.             }
  1387.         }
  1388.         else {
  1389.             switch (tipoStatistica) {
  1390.             case STATISTICHE_ORARIE:
  1391.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheOrarieSqlError;
  1392.             case STATISTICHE_GIORNALIERE:
  1393.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheGiornaliereSqlError;
  1394.             case STATISTICHE_SETTIMANALI:
  1395.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheSettimanaliSqlError;
  1396.             case STATISTICHE_MENSILI:
  1397.                 return OpenSPCoop2Logger.loggerOpenSPCoopStatisticheMensiliSqlError;
  1398.             }
  1399.         }
  1400.         return null;
  1401.     }
  1402.     
  1403.     public static Logger getLoggerOpenSPCoopConsegnaContenuti(boolean debug) {
  1404.         if(debug) {
  1405.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenuti;
  1406.         }
  1407.         else {
  1408.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiError;
  1409.         }
  1410.     }
  1411.     
  1412.     public static Logger getLoggerOpenSPCoopConsegnaContenutiSql(boolean debug) {
  1413.         if(debug) {
  1414.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSql;
  1415.         }
  1416.         else {
  1417.             return OpenSPCoop2Logger.loggerOpenSPCoopConsegnaContenutiSqlError;
  1418.         }
  1419.     }
  1420.     
  1421.     public static Logger getLoggerOpenSPCoopPlugins(boolean debug) {
  1422.         if(debug) {
  1423.             return OpenSPCoop2Logger.loggerOpenSPCoopPlugins;
  1424.         }
  1425.         else {
  1426.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsError;
  1427.         }
  1428.     }
  1429.     
  1430.     public static Logger getLoggerOpenSPCoopPluginsSql(boolean debug) {
  1431.         if(debug) {
  1432.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsSql;
  1433.         }
  1434.         else {
  1435.             return OpenSPCoop2Logger.loggerOpenSPCoopPluginsSqlError;
  1436.         }
  1437.     }
  1438.     
  1439.     public static Logger getLoggerOpenSPCoopGestoreChiaviPDND(boolean debug) {
  1440.         if(debug) {
  1441.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDND;
  1442.         }
  1443.         else {
  1444.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreChiaviPDNDError;
  1445.         }
  1446.     }
  1447.     
  1448.     public static Logger getLoggerOpenSPCoopGestoreOperazioniRemote(boolean debug) {
  1449.         if(debug) {
  1450.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemote;
  1451.         }
  1452.         else {
  1453.             return OpenSPCoop2Logger.loggerOpenSPCoopGestoreOperazioniRemoteError;
  1454.         }
  1455.     }
  1456.     
  1457.     public static List<IDiagnosticProducer> getLoggerMsgDiagnosticoOpenSPCoopAppender() {
  1458.         return OpenSPCoop2Logger.loggerMsgDiagnosticoOpenSPCoopAppender;
  1459.     }

  1461.     public static List<String> getTipoMsgDiagnosticoOpenSPCoopAppender() {
  1462.         return OpenSPCoop2Logger.tipoMsgDiagnosticoOpenSPCoopAppender;
  1463.     }

  1465.     public static List<ITracciaProducer> getLoggerTracciamentoOpenSPCoopAppender() {
  1466.         return OpenSPCoop2Logger.loggerTracciamentoOpenSPCoopAppender;
  1467.     }

  1469.     public static List<String> getTipoTracciamentoOpenSPCoopAppender() {
  1470.         return OpenSPCoop2Logger.tipoTracciamentoOpenSPCoopAppender;
  1471.     }

  1473. }

Created with JaCoCo 0.8.8.202204050719