OpenSPCoop2Startup.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.services;

  25. import java.io.ByteArrayOutputStream;
  26. import java.io.File;
  27. import java.io.FileInputStream;
  28. import java.io.FileOutputStream;
  29. import java.io.OutputStream;
  30. import java.rmi.RemoteException;
  31. import java.security.Provider;
  32. import java.security.SecureRandom;
  33. import java.security.Security;
  34. import java.sql.Connection;
  35. import java.util.ArrayList;
  36. import java.util.Enumeration;
  37. import java.util.HashMap;
  38. import java.util.List;
  39. import java.util.Locale;
  40. import java.util.Map;
  41. import java.util.Properties;
  42. import java.util.logging.Level;

  44. import javax.servlet.ServletContext;
  45. import javax.servlet.ServletContextEvent;
  46. import javax.servlet.ServletContextListener;
  47. import javax.xml.namespace.QName;
  48. import javax.xml.soap.SOAPElement;
  49. import javax.xml.soap.SOAPHeader;
  50. import javax.xml.soap.SOAPHeaderElement;
  51. import javax.xml.xpath.XPathFactory;

  53. import org.apache.commons.lang.StringUtils;
  54. import org.apache.cxf.rs.security.jose.common.KeyManagementUtils;
  55. import org.apache.wss4j.dom.handler.WSHandler;
  56. import org.bouncycastle.crypto.CryptoServicesRegistrar;
  57. import org.jminix.console.tool.StandaloneMiniConsole;
  58. import org.openspcoop2.core.commons.CoreException;
  59. import org.openspcoop2.core.commons.DBUtils;
  60. import org.openspcoop2.core.config.AccessoConfigurazionePdD;
  61. import org.openspcoop2.core.config.AccessoDatiAttributeAuthority;
  62. import org.openspcoop2.core.config.AccessoDatiAutenticazione;
  63. import org.openspcoop2.core.config.AccessoDatiAutorizzazione;
  64. import org.openspcoop2.core.config.AccessoDatiGestioneToken;
  65. import org.openspcoop2.core.config.AccessoDatiKeystore;
  66. import org.openspcoop2.core.config.AccessoDatiRichieste;
  67. import org.openspcoop2.core.config.AccessoRegistro;
  68. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  69. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  70. import org.openspcoop2.core.config.constants.StatoFunzionalitaConWarning;
  71. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  72. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  73. import org.openspcoop2.core.constants.CostantiDB;
  74. import org.openspcoop2.core.constants.CostantiLabel;
  75. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  76. import org.openspcoop2.core.controllo_traffico.constants.CacheAlgorithm;
  77. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  78. import org.openspcoop2.core.eventi.Evento;
  79. import org.openspcoop2.core.eventi.constants.CodiceEventoStatoGateway;
  80. import org.openspcoop2.core.eventi.constants.TipoEvento;
  81. import org.openspcoop2.core.eventi.constants.TipoSeverita;
  82. import org.openspcoop2.core.eventi.utils.SeveritaConverter;
  83. import org.openspcoop2.core.registry.driver.IDAccordoCooperazioneFactory;
  84. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  85. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  86. import org.openspcoop2.core.statistiche.constants.TipoIntervalloStatistico;
  87. import org.openspcoop2.message.AbstractBaseOpenSPCoop2Message;
  88. import org.openspcoop2.message.AbstractBaseOpenSPCoop2MessageDynamicContent;
  89. import org.openspcoop2.message.AttachmentsProcessingMode;
  90. import org.openspcoop2.message.OpenSPCoop2Message;
  91. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  92. import org.openspcoop2.message.OpenSPCoop2MessageFactory_impl;
  93. import org.openspcoop2.message.constants.MessageRole;
  94. import org.openspcoop2.message.constants.MessageType;
  95. import org.openspcoop2.message.rest.AbstractLazyContent;
  96. import org.openspcoop2.message.soap.SoapUtils;
  97. import org.openspcoop2.message.soap.reader.OpenSPCoop2MessageSoapStreamReader;
  98. import org.openspcoop2.monitor.engine.dynamic.CorePluginLoader;
  99. import org.openspcoop2.pdd.config.ClassNameProperties;
  100. import org.openspcoop2.pdd.config.ConfigurazioneCoda;
  101. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  102. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  103. import org.openspcoop2.pdd.config.DBConsegneMessageBoxManager;
  104. import org.openspcoop2.pdd.config.DBConsegnePreseInCaricoManager;
  105. import org.openspcoop2.pdd.config.DBManager;
  106. import org.openspcoop2.pdd.config.DBStatisticheManager;
  107. import org.openspcoop2.pdd.config.DBTransazioniManager;
  108. import org.openspcoop2.pdd.config.DynamicClusterManager;
  109. import org.openspcoop2.pdd.config.GeneralInstanceProperties;
  110. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  111. import org.openspcoop2.pdd.config.PDNDConfig;
  112. import org.openspcoop2.pdd.config.PDNDConfigUtilities;
  113. import org.openspcoop2.pdd.config.PddProperties;
  114. import org.openspcoop2.pdd.config.PreLoadingConfig;
  115. import org.openspcoop2.pdd.config.QueueManager;
  116. import org.openspcoop2.pdd.config.SystemPropertiesManager;
  117. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  118. import org.openspcoop2.pdd.core.CostantiPdD;
  119. import org.openspcoop2.pdd.core.FileSystemSerializer;
  120. import org.openspcoop2.pdd.core.GestoreMessaggi;
  121. import org.openspcoop2.pdd.core.GestoreRichieste;
  122. import org.openspcoop2.pdd.core.PdDContext;
  123. import org.openspcoop2.pdd.core.StatoServiziPdD;
  124. import org.openspcoop2.pdd.core.autenticazione.GestoreAutenticazione;
  125. import org.openspcoop2.pdd.core.autorizzazione.GestoreAutorizzazione;
  126. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.GestoreLoadBalancerCaching;
  127. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  128. import org.openspcoop2.pdd.core.byok.DriverBYOK;
  129. import org.openspcoop2.pdd.core.byok.DriverBYOKUtilities;
  130. import org.openspcoop2.pdd.core.cache.GestoreCacheCleaner;
  131. import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
  132. import org.openspcoop2.pdd.core.controllo_traffico.GestoreControlloTraffico;
  133. import org.openspcoop2.pdd.core.controllo_traffico.INotify;
  134. import org.openspcoop2.pdd.core.controllo_traffico.NotificatoreEventi;
  135. import org.openspcoop2.pdd.core.controllo_traffico.policy.DatiStatisticiDAOManager;
  136. import org.openspcoop2.pdd.core.controllo_traffico.policy.GestoreCacheControlloTraffico;
  137. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.GestorePolicyAttive;
  138. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.GestorePolicyAttiveInMemory;
  139. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.HazelcastManager;
  140. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.redisson.RedissonManager;
  141. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  142. import org.openspcoop2.pdd.core.eventi.GestoreEventi;
  143. import org.openspcoop2.pdd.core.handlers.ExitContext;
  144. import org.openspcoop2.pdd.core.handlers.GeneratoreCasualeDate;
  145. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  146. import org.openspcoop2.pdd.core.handlers.HandlerException;
  147. import org.openspcoop2.pdd.core.handlers.InitContext;
  148. import org.openspcoop2.pdd.core.integrazione.peer.RegexpPeerHeaderDescriptor;
  149. import org.openspcoop2.pdd.core.jmx.AccessoRegistroServizi;
  150. import org.openspcoop2.pdd.core.jmx.ConfigurazioneSistema;
  151. import org.openspcoop2.pdd.core.jmx.GestoreRisorseJMXGovWay;
  152. import org.openspcoop2.pdd.core.jmx.InformazioniStatoPorta;
  153. import org.openspcoop2.pdd.core.jmx.InformazioniStatoPortaCache;
  154. import org.openspcoop2.pdd.core.jmx.StatoServiziJMXResource;
  155. import org.openspcoop2.pdd.core.keystore.GestoreKeystoreCaching;
  156. import org.openspcoop2.pdd.core.keystore.RemoteStoreProviderDriver;
  157. import org.openspcoop2.pdd.core.response_caching.GestoreCacheResponseCaching;
  158. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  159. import org.openspcoop2.pdd.core.token.GestoreToken;
  160. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  161. import org.openspcoop2.pdd.logger.DiagnosticInputStream;
  162. import org.openspcoop2.pdd.logger.LogLevels;
  163. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  164. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  165. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  166. import org.openspcoop2.pdd.logger.filetrace.FileTraceConfig;
  167. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  168. import org.openspcoop2.pdd.mdb.InoltroBuste;
  169. import org.openspcoop2.pdd.services.core.RicezioneBuste;
  170. import org.openspcoop2.pdd.services.core.RicezioneContenutiApplicativi;
  171. import org.openspcoop2.pdd.services.skeleton.IntegrationManager;
  172. import org.openspcoop2.pdd.timers.TimerClusterDinamicoThread;
  173. import org.openspcoop2.pdd.timers.TimerClusteredRateLimitingLocalCache;
  174. import org.openspcoop2.pdd.timers.TimerConsegnaContenutiApplicativi;
  175. import org.openspcoop2.pdd.timers.TimerConsegnaContenutiApplicativiThread;
  176. import org.openspcoop2.pdd.timers.TimerEventiThread;
  177. import org.openspcoop2.pdd.timers.TimerException;
  178. import org.openspcoop2.pdd.timers.TimerFileSystemRecoveryThread;
  179. import org.openspcoop2.pdd.timers.TimerGestoreBusteNonRiscontrate;
  180. import org.openspcoop2.pdd.timers.TimerGestoreBusteNonRiscontrateLib;
  181. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  182. import org.openspcoop2.pdd.timers.TimerGestoreMessaggiLib;
  183. import org.openspcoop2.pdd.timers.TimerGestoreMessaggiThread;
  184. import org.openspcoop2.pdd.timers.TimerGestorePuliziaMessaggiAnomali;
  185. import org.openspcoop2.pdd.timers.TimerGestorePuliziaMessaggiAnomaliLib;
  186. import org.openspcoop2.pdd.timers.TimerGestorePuliziaMessaggiAnomaliThread;
  187. import org.openspcoop2.pdd.timers.TimerGestoreRepositoryBuste;
  188. import org.openspcoop2.pdd.timers.TimerGestoreRepositoryBusteLib;
  189. import org.openspcoop2.pdd.timers.TimerGestoreRepositoryBusteThread;
  190. import org.openspcoop2.pdd.timers.TimerLock;
  191. import org.openspcoop2.pdd.timers.TimerMonitoraggioRisorseThread;
  192. import org.openspcoop2.pdd.timers.TimerRepositoryStatefulThread;
  193. import org.openspcoop2.pdd.timers.TimerState;
  194. import org.openspcoop2.pdd.timers.TimerStatisticheLib;
  195. import org.openspcoop2.pdd.timers.TimerStatisticheThread;
  196. import org.openspcoop2.pdd.timers.TimerThresholdThread;
  197. import org.openspcoop2.pdd.timers.TimerUtils;
  198. import org.openspcoop2.pdd.timers.TipoLock;
  199. import org.openspcoop2.pdd.timers.pdnd.TimerGestoreCacheChiaviPDND;
  200. import org.openspcoop2.pdd.timers.pdnd.TimerGestoreCacheChiaviPDNDLib;
  201. import org.openspcoop2.pdd.timers.pdnd.TimerGestoreChiaviPDND;
  202. import org.openspcoop2.pdd.timers.pdnd.TimerGestoreChiaviPDNDLib;
  203. import org.openspcoop2.pdd.timers.proxy.TimerGestoreOperazioniRemote;
  204. import org.openspcoop2.pdd.timers.proxy.TimerGestoreOperazioniRemoteLib;
  205. import org.openspcoop2.pdd.timers.proxy.TimerSvecchiamentoOperazioniRemote;
  206. import org.openspcoop2.pdd.timers.proxy.TimerSvecchiamentoOperazioniRemoteLib;
  207. import org.openspcoop2.protocol.basic.Costanti;
  208. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  209. import org.openspcoop2.protocol.engine.driver.repository.IGestoreRepository;
  210. import org.openspcoop2.protocol.manifest.constants.ServiceBinding;
  211. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  212. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  213. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  214. import org.openspcoop2.protocol.sdk.state.RequestConfig;
  215. import org.openspcoop2.protocol.sdk.state.RequestThreadContext;
  216. import org.openspcoop2.protocol.sdk.state.StateMessage;
  217. import org.openspcoop2.protocol.utils.ErroriProperties;
  218. import org.openspcoop2.protocol.utils.ModIUtils;
  219. import org.openspcoop2.security.keystore.cache.GestoreKeystoreCache;
  220. import org.openspcoop2.security.keystore.cache.RemoteStoreClientInfoCache;
  221. import org.openspcoop2.security.message.WsuIdAllocator;
  222. import org.openspcoop2.security.message.engine.MessageSecurityFactory;
  223. import org.openspcoop2.security.utils.ExternalPWCallback;
  224. import org.openspcoop2.utils.LoggerWrapperFactory;
  225. import org.openspcoop2.utils.TipiDatabase;
  226. import org.openspcoop2.utils.Utilities;
  227. import org.openspcoop2.utils.beans.WriteToSerializerType;
  228. import org.openspcoop2.utils.cache.Cache;
  229. import org.openspcoop2.utils.certificate.CertificateFactory;
  230. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  231. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  232. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  233. import org.openspcoop2.utils.certificate.remote.RemoteStoreConfig;
  234. import org.openspcoop2.utils.date.DateManager;
  235. import org.openspcoop2.utils.date.DateUtils;
  236. import org.openspcoop2.utils.dch.MailcapActivationReader;
  237. import org.openspcoop2.utils.digest.MessageDigestFactory;
  238. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  239. import org.openspcoop2.utils.id.UniversallyUniqueIdentifierProducer;
  240. import org.openspcoop2.utils.id.serial.InfoStatistics;
  241. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  242. import org.openspcoop2.utils.io.notifier.unblocked.PipedUnblockedStreamFactory;
  243. import org.openspcoop2.utils.jdbc.JDBCUtilities;
  244. import org.openspcoop2.utils.json.JsonPathExpressionEngine;
  245. import org.openspcoop2.utils.json.YamlSnakeLimits;
  246. import org.openspcoop2.utils.properties.MapProperties;
  247. import org.openspcoop2.utils.random.RandomUtilities;
  248. import org.openspcoop2.utils.resources.FileSystemMkdirConfig;
  249. import org.openspcoop2.utils.resources.FileSystemUtilities;
  250. import org.openspcoop2.utils.resources.GestoreJNDI;
  251. import org.openspcoop2.utils.resources.Loader;
  252. import org.openspcoop2.utils.security.ProviderUtils;
  253. import org.openspcoop2.utils.semaphore.Semaphore;
  254. import org.openspcoop2.utils.semaphore.SemaphoreConfiguration;
  255. import org.openspcoop2.utils.semaphore.SemaphoreMapping;
  256. import org.openspcoop2.utils.xml.AbstractXMLUtils;
  257. import org.openspcoop2.utils.xml.XSDSchemaCollection;
  258. import org.slf4j.Logger;

  260. import com.sun.xml.messaging.saaj.soap.MessageImpl;



  264. /**
  265.  * Implementazione del punto di Startup dell'applicazione WEB
  266.  * 
  267.  * @author Marcello Spadafora (ma.spadafora@finsiel.it)
  268.  * @author Poli Andrea (apoli@link.it)
  269.  * @author $Author$
  270.  * @version $Rev$, $Date$
  271.  */

  273. public class OpenSPCoop2Startup implements ServletContextListener {

  275.     /** Logger utilizzato per segnalazione di errori. */
  276.     private static final String LOG_CATEGORY_STARTUP = "govway.startup";
  277.     private static Logger log = LoggerWrapperFactory.getLogger(LOG_CATEGORY_STARTUP);
  278.     public static void logStartupInfo(String msg) {
  279.         OpenSPCoop2Startup.log.info(msg);
  280.     }
  281.     public static void logStartupError(String msg, Exception e) {
  282.         OpenSPCoop2Startup.log.error(msg,e);
  283.     }

  285.     /** Variabile che indica il Nome del modulo attuale di OpenSPCoop */
  286.     private static final String ID_MODULO = "InizializzazioneRisorse";

  288.     /** Indicazione se sta avvendendo un contextDestroyed */
  289.     public static boolean contextDestroyed = false;
  290.     public static synchronized void setContextDestroyed(boolean value) {
  291.         contextDestroyed = value;
  292.     }

  294.     /** Context della Servlet */
  295.     ServletContext servletContext;

  297.     /** Indicazione su una corretta inizializzazione */
  298.     public static boolean initialize = false;
  299.     
  300.     /** Indicazione su una corretta inizializzazione della configurazione del Logging (Utile per l'integrazione con il pool utils via reflection) */
  301.     public static boolean initializeLog = false;

  303.     /** Timer per la gestione della funzionalita' 'RiscontriScaduti' */
  304.     private TimerGestoreBusteNonRiscontrate timerRiscontri;

  306.     /** Timer per l'eliminazione dei messaggi gestiti */
  307.     private TimerGestoreMessaggi timerEliminazioneMsg;
  308.     private TimerGestoreMessaggiThread threadEliminazioneMsg;

  310.     /** Timer per l'eliminazione dei messaggi anomali */
  311.     private TimerGestorePuliziaMessaggiAnomali timerPuliziaMsgAnomali;
  312.     private TimerGestorePuliziaMessaggiAnomaliThread threadPuliziaMsgAnomali;

  314.     /** Timer per l'eliminazione delle buste gestite */
  315.     private TimerGestoreRepositoryBuste timerRepositoryBuste;
  316.     private TimerGestoreRepositoryBusteThread threadRepositoryBuste;

  318.     /** Gestore Threshold */
  319.     private TimerThresholdThread timerThreshold = null;

  321.     /** Gestore Monitoraggio Risorse */
  322.     private TimerMonitoraggioRisorseThread timerMonitoraggioRisorse = null;

  324.     /** Timer per la gestione di riconsegna ContenutiApplicativi */
  325.     private Map<String, TimerConsegnaContenutiApplicativiThread> threadConsegnaContenutiApplicativiMap;
  326.     public static Map<String, TimerConsegnaContenutiApplicativiThread> threadConsegnaContenutiApplicativiRefMap;
  327.     
  328.     /** Gestore risorse JMX */
  329.     private GestoreRisorseJMXGovWay gestoreRisorseJMX = null;
  330.     public static GestoreRisorseJMXGovWay gestoreRisorseJMX_staticInstance = null;
  331.     
  332.     /** Gestore eventi */
  333.     private GestoreEventi gestoreEventi = null;
  334.     private TimerEventiThread threadEventi;
  335.     
  336.     /** Timer FileSystemRecovery */
  337.     private TimerFileSystemRecoveryThread threadFileSystemRecovery = null;
  338.     
  339.     /** Timer FileSystemRecovery */
  340.     private TimerRepositoryStatefulThread threadRepositoryStateful = null;
  341.     
  342.     /** Timer per la generazione delle statistiche */
  343.     private TimerStatisticheThread threadGenerazioneStatisticheOrarie;
  344.     private TimerStatisticheThread threadGenerazioneStatisticheGiornaliere;
  345.     private TimerStatisticheThread threadGenerazioneStatisticheSettimanali;
  346.     private TimerStatisticheThread threadGenerazioneStatisticheMensili;
  347.     private TimerStatisticheThread threadPdndTracciamentoGenerazione;
  348.     private TimerStatisticheThread threadPdndTracciamentoPubblicazione;
  349.     
  350.     /** Timer per la gestione delle chiavi da PDND */
  351.     private TimerGestoreChiaviPDND threadGestoreChiaviPDND;
  352.     private TimerGestoreCacheChiaviPDND threadGestoreCacheChiaviPDND;
  353.     private boolean threadGestoreChiaviPDNDEnabled = false;
  354.     
  355.     /** Timer per la gestione delle operazioni remote in un cluster dinamico */
  356.     private TimerGestoreOperazioniRemote threadGestoreOperazioniRemote;
  357.     private TimerSvecchiamentoOperazioniRemote threadSvecchiamentoOperazioniRemote;
  358.     private boolean threadGestoreOperazioniRemoteEnabled = false;
  359.     
  360.     /** DynamicCluster */
  361.     private static TimerClusterDinamicoThread threadClusterDinamico;
  362.     
  363.     /** Clustered Rate Limiting Timer */
  364.     private static TimerClusteredRateLimitingLocalCache timerClusteredRateLimitingLocalCache;
  365.         
  366.     /** UUIDProducer */
  367.     private UniversallyUniqueIdentifierProducer universallyUniqueIdentifierProducer;
  368.     
  369.     /** indicazione se è un server j2ee */
  370.     private boolean serverJ2EE = false;
  371.     protected long startDate ;

  373.     /** PdDContext */
  374.     private PdDContext pddContext = new PdDContext();
  375.     
  376.     /** OpenSPCoopStartupThread */
  377.     private OpenSPCoopStartupThread th;
  378.     
  379.     /** Jminix StandaloneMiniConsole */
  380.     private static StandaloneMiniConsole jminixStandaloneConsole;

  382.     /**
  383.      * Startup dell'applicazione WEB di OpenSPCoop
  384.      *
  385.      * @param sce Servlet Context Event
  386.      * 
  387.      */
  388.     @Override
  389.     public void contextInitialized(ServletContextEvent sce) {

  391.         OpenSPCoop2Startup.setContextDestroyed(false);
  392.         
  393.         this.startDate = System.currentTimeMillis();
  394.         
  395.         /* ------  Ottiene il servletContext --------*/
  396.         this.servletContext = sce.getServletContext();
  397.         this.th = new OpenSPCoopStartupThread();
  398.         new Thread(this.th).start();

  400.     }

  402.     class OpenSPCoopStartupThread implements Runnable {

  404.         private void logError(String msg){
  405.             this.logError(msg,null);
  406.         }
  407.         private void logError(String msg,Throwable e){
  408.             if(e==null)
  409.                 OpenSPCoop2Startup.log.error(msg);
  410.             else
  411.                 OpenSPCoop2Startup.log.error(msg,e);
  412.             if(OpenSPCoop2Logger.isLoggerOpenSPCoopConsoleStartupAgganciatoLog()){
  413.                 // per farlo finire anche sul server.log
  414.                 System.err.println(msg);
  415.                 if(e!=null){
  416.                     e.printStackTrace(System.err);
  417.                 }
  418.             }
  419.         }
  420.         

  422.         public OpenSPCoopStartupThread() {                        
  423.         }

  425.         @Override
  426.         public void run() {

  428.             
  429.             
  430.             
  431.             /* ------------ LogConsole -------------------- */
  432.             // Inizializza lo startup log, utile per web spheare
  433.             if(!OpenSPCoop2Logger.initializeLogConsole(OpenSPCoop2Startup.log)){
  434.                 return;
  435.             }
  436.             OpenSPCoop2Startup.log = LoggerWrapperFactory.getLogger(LOG_CATEGORY_STARTUP);
  437.             
  438.             
  439.             
  440.             
  441.             


  444.             
  445.                     
  446.             
  447.             
  448.             
  449.             

  451.             /* ------------- Inizializzo ClassNameProperties di OpenSPCoop --------------- */
  452.             if( !ClassNameProperties.initialize(true)){
  453.                 this.logError("Riscontrato errore durante l'inizializzazione del reader di 'govway.classRegistry.properties'");
  454.                 return;
  455.             }
  456.             ClassNameProperties classNameReader = ClassNameProperties.getInstance();




  461.             
  462.             
  463.             
  464.             
  465.             
  466.             
  467.             /* ------------- Loader --------------- */
  468.             GeneralInstanceProperties instanceProperties = new GeneralInstanceProperties();
  469.             Object [] o = null;
  470.             Properties openspcoopP = null;
  471.             Properties classNameP = null;
  472.             Properties loggerP = null;
  473.             Properties localConfig = null;
  474.             Properties cacheP = null;
  475.             try{
  476.                 o = instanceProperties.reads(OpenSPCoop2Startup.log);
  477.             }catch(Exception e){
  478.                 e.printStackTrace(System.err);
  479.             }
  480.             try{
  481.                 if(o!=null){
  482.                     Loader.initialize((java.lang.ClassLoader)o[0]);
  483.                     try{
  484.                         openspcoopP=(Properties)o[1];
  485.                         classNameP=(Properties)o[2];
  486.                         loggerP = (Properties)o[4];
  487.                         localConfig = (Properties)o[5];
  488.                         cacheP = (Properties)o[7];
  489.                     }catch(Exception e){
  490.                         // ignore
  491.                     }
  492.                 }else{
  493.                     Loader.initialize();
  494.                 }
  495.             }catch(Exception e){
  496.                 this.logError("Loader non istanziato: "+e.getMessage(),e);
  497.                 return;
  498.             }

  500.             
  501.             







  509.             /* ------------- Proprieta' di OpenSPCoop --------------- */
  510.             if( !OpenSPCoop2Properties.initialize(openspcoopP)){
  511.                 this.logError("Riscontrato errore durante l'inizializzazione del reader di 'govway.properties'");
  512.                 return;
  513.             }
  514.             OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  515.             // Di seguito vengono attivati gli engine che richiedono di essere caricati prima della validazione del file di proprietà
  516.             
  517.             
  518.             
  519.             
  520.             
  521.             
  522.             
  523.             /* ----------- Map (environment) ------------ */
  524.             try {
  525.                 String mapConfig = propertiesReader.getEnvMapConfig();
  526.                 if(StringUtils.isNotEmpty(mapConfig)) {
  527.                     MapProperties.initialize(OpenSPCoop2Startup.log, mapConfig, propertiesReader.isEnvMapConfigRequired());
  528.                     MapProperties mapProperties = MapProperties.getInstance();
  529.                     mapProperties.initEnvironment();
  530.                     String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  531.                             "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  532.                             "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  533.                             "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  534.                             "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  535.                             "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  536.                     OpenSPCoop2Startup.log.info(msgInit);
  537.                 }
  538.             } catch (Exception e) {
  539.                 OpenSPCoop2Startup.log.error("Inizializzazione ambiente non riuscita: "+e.getMessage(),e);
  540.                 return;
  541.             }
  542.             
  543.             
  544.             
  545.             
  546.             
  547.             
  548.             
  549.             /* ----------- BouncyCastle ------------ */
  550.             if(propertiesReader.isLoadBouncyCastle()){ 
  551.                 ProviderUtils.addBouncyCastleAfterSun(true);
  552.                 OpenSPCoop2Startup.logStartupInfo("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  553.                 
  554.                 if(propertiesReader.getBouncyCastleSecureRandomAlgorithm()!=null) {
  555.                     try{
  556.                         SecureRandom secureRandom = SecureRandom.getInstance(propertiesReader.getBouncyCastleSecureRandomAlgorithm());
  557.                         CryptoServicesRegistrar.setSecureRandom(secureRandom);
  558.                         OpenSPCoop2Startup.logStartupInfo("Aggiunto default SecureRandom '"+secureRandom.getAlgorithm()+"' in CryptoServicesRegistrar di Bouncycastle");
  559.                     }catch(Exception e){
  560.                         this.logError("Inizializzazione SecureRandom in BouncyCastle fallita",e);
  561.                         return;
  562.                     }
  563.                 }
  564.                 else {
  565.                     SecureRandom secureRandom = CryptoServicesRegistrar.getSecureRandom();
  566.                     if(secureRandom!=null) {
  567.                         OpenSPCoop2Startup.logStartupInfo("SecureRandom used in CryptoServicesRegistrar di Bouncycastle: '"+secureRandom.getAlgorithm()+"'");
  568.                     }
  569.                 }               
  570.             }
  571.             
  572.             
  573.             
  574.             
  575.             
  576.             
  577.             /* ----------- Gestori HSM ------------ */
  578.             try {
  579.                 String hsmConfig = propertiesReader.getHSMConfig();
  580.                 if(StringUtils.isNotEmpty(hsmConfig)) {
  581.                     File f = new File(hsmConfig);
  582.                     HSMManager.init(f, propertiesReader.isHSMConfigRequired(), OpenSPCoop2Startup.log, true);
  583.                     HSMManager hsmManager = HSMManager.getInstance();
  584.                     hsmManager.providerInit(OpenSPCoop2Startup.log, propertiesReader.isHSMConfigUniqueProviderInstance());
  585.                     String msgInit = "Gestore HSM inizializzato; keystore registrati: "+hsmManager.getKeystoreTypes();
  586.                     OpenSPCoop2Startup.log.info(msgInit);
  587.                 }
  588.             } catch (Exception e) {
  589.                 OpenSPCoop2Startup.log.error("Inizializzazione Gestore HSM non riuscita: "+e.getMessage(),e);
  590.                 return;
  591.             }
  592.             
  593.             
  594.             
  595.             
  596.             
  597.             
  598.             /* ----------- Gestori OCSP ------------ */
  599.             try {
  600.                 String ocspConfig = propertiesReader.getOCSPConfig();
  601.                 if(StringUtils.isNotEmpty(ocspConfig)) {
  602.                     File f = new File(ocspConfig);
  603.                     OCSPManager.init(f, propertiesReader.isOCSPConfigRequired(), propertiesReader.isOCSPConfigLoadDefault(), OpenSPCoop2Startup.log);
  604.                     OCSPManager ocspManager = OCSPManager.getInstance();
  605.                     String msgInit = "Gestore OCSP inizializzato; policy registrate: "+ocspManager.getOCSPConfigTypes();
  606.                     OpenSPCoop2Startup.log.info(msgInit);
  607.                 }
  608.             } catch (Exception e) {
  609.                 OpenSPCoop2Startup.log.error("Inizializzazione Gestore OCSP non riuscita: "+e.getMessage(),e);
  610.                 return;
  611.             }
  612.             
  613.             
  614.             
  615.             
  616.             
  617.             
  618.             /* ----------- Gestori BYOK ------------ */
  619.             BYOKManager byokManager = null;
  620.             try {
  621.                 String byokConfig = propertiesReader.getBYOKConfig();
  622.                 if(StringUtils.isNotEmpty(byokConfig)) {
  623.                     File f = new File(byokConfig);
  624.                     BYOKManager.init(f, propertiesReader.isBYOKConfigRequired(), OpenSPCoop2Startup.log);
  625.                     byokManager = BYOKManager.getInstance();
  626.                     String msgInit = "Gestore BYOK inizializzato;"+
  627.                             "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  628.                             "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  629.                             "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  630.                     OpenSPCoop2Startup.log.info(msgInit);
  631.                 }
  632.             } catch (Exception e) {
  633.                 OpenSPCoop2Startup.log.error("Inizializzazione Gestore BYOK non riuscita: "+e.getMessage(),e);
  634.                 return;
  635.             }
  636.             
  637.     
  638.             
  639.             
  640.             
  641.             
  642.             /* ----------- Secrets (environment) ------------ */
  643.             try {
  644.                 String secretsConfig = propertiesReader.getBYOKEnvSecretsConfig();
  645.                 if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  646.                     BYOKMapProperties.initialize(OpenSPCoop2Startup.log, secretsConfig, propertiesReader.isBYOKEnvSecretsConfigRequired(), 
  647.                             true,
  648.                             null, false);
  649.                     BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  650.                     secretsProperties.setGovWayStarted(false);
  651.                     secretsProperties.initEnvironment();
  652.                     boolean existsUnwrapPropertiesAfterGovWayStartup = secretsProperties.isExistsUnwrapPropertiesAfterGovWayStartup();
  653.                     String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"'"+
  654.                             "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  655.                             "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  656.                             "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription()+
  657.                             "\n\tExistsUnwrapPropertiesAfterGovWayStartup: "+existsUnwrapPropertiesAfterGovWayStartup;
  658.                     OpenSPCoop2Startup.log.info(msgInit);
  659.                 }
  660.             } catch (Exception e) {
  661.                 OpenSPCoop2Startup.log.error("Inizializzazione ambiente (secrets) non riuscita: "+e.getMessage(),e);
  662.                 return;
  663.             }
  664.             
  665.             
  666.             
  667.             
  668.             
  669.             
  670.             
  671.             /* ------------- Verifica Proprieta' di OpenSPCoop --------------- */
  672.             try{
  673.                 propertiesReader.checkOpenSPCoopHome();
  674.             }catch(Exception e){
  675.                 this.logError(e.getMessage(),e);
  676.                 if(StatoFunzionalitaConWarning.ABILITATO.equals(propertiesReader.getCheckOpenSPCoopHome())){
  677.                     return;
  678.                 }
  679.             }
  680.             classNameReader.refreshLocalProperties(classNameP,propertiesReader.getRootDirectory()); // prima della validazione
  681.             if(o!=null){
  682.                 if(!propertiesReader.validaConfigurazione((java.lang.ClassLoader)o[0])){
  683.                     return;
  684.                 }
  685.                 if(!classNameReader.validaConfigurazione((java.lang.ClassLoader)o[0], propertiesReader.getDatabaseType())){
  686.                     return;
  687.                 }
  688.             }else{
  689.                 if(!propertiesReader.validaConfigurazione(null)){
  690.                     return;
  691.                 }
  692.                 if(!classNameReader.validaConfigurazione(null, propertiesReader.getDatabaseType())){
  693.                     return;
  694.                 }
  695.             }
  696.             
  697.             OpenSPCoop2Startup.this.serverJ2EE = propertiesReader.isServerJ2EE();
  698.             if(propertiesReader.getClassLoader()!=null){
  699.                 try{
  700.                     Loader.update(propertiesReader.getClassLoader());
  701.                 }catch(Exception e){
  702.                     this.logError("Loader non aggiornato: "+e.getMessage(),e);
  703.                     return;
  704.                 }   
  705.             }
  706.             Loader loader = Loader.getInstance();


  709.             
  710.             
  711.             
  712.             
  713.             
  714.             
  715.             
  716.             /* ------------- Inizializzo Errori di OpenSPCoop --------------- */
  717.             try {
  718.                 ErroriProperties.initialize(propertiesReader.getRootDirectory(), log, loader);
  719.             }catch(Exception e) {
  720.                 this.logError("Riscontrato errore durante l'inizializzazione del reader 'errori.properties'");
  721.                 return;
  722.             }
  723.             
  724.             
  725.             
  726.                 
  727.             /*
  728.              * Nella classe ./src/main/java/com/sun/xml/messaging/saaj/soap/EnvelopeFactory.java 
  729.              * viene inizializzato un pool di sax parser che vengono usati per parsare il messaggio.
  730.              * Questo poichè ogni parser non può essere utilizzato simultaneamente da thread diversi, altrimenti si ottiene l'errore "org.xml.sax.SAXException: FWK005 parse may not be called while parsing"
  731.              * Per default viene inizializzato con un pool di 5
  732.              * public class EnvelopeFactory {
  733.              *    private static final String SAX_PARSER_POOL_SIZE_PROP_NAME = "com.sun.xml.messaging.saaj.soap.saxParserPoolSize";
  734.              *    private static final int DEFAULT_SAX_PARSER_POOL_SIZE = 5;
  735.              **/
  736.             System.setProperty("com.sun.xml.messaging.saaj.soap.saxParserPoolSize", propertiesReader.getSoapMessageSaajSaxParserPoolSize()+"");
  737.             OpenSPCoop2Startup.logStartupInfo("saaj.soap.saxParserPoolSize="+propertiesReader.getSoapMessageSaajSaxParserPoolSize());
  738.             
  739.             /*
  740.              * ApacheXMLDSig: usato da wssecurity come XMLSignatureFactory, come si può vedere nella classe 'WSSecSignature'
  741.              **/
  742.             if(propertiesReader.isLoadApacheXMLDSig()) {
  743.                 String providerName_ApacheXMLDSig = "ApacheXMLDSig";
  744.                 Provider currentProvider = Security.getProvider(providerName_ApacheXMLDSig);
  745.                 if (currentProvider != null) {
  746.                     Security.removeProvider(providerName_ApacheXMLDSig);
  747.                 }
  748.                 Security.insertProviderAt(new org.apache.jcp.xml.dsig.internal.dom.XMLDSigRI(),2); // lasciare alla posizione 1 il provider 'SUN'
  749.                 OpenSPCoop2Startup.logStartupInfo("Aggiunto Security Provider ApacheXMLDSig");
  750.             }
  751.                         
  752.             /*
  753.              *  Necessario in jboss7 per evitare errore 'error constructing MAC: java.lang.SecurityException: JCE cannot authenticate the provider BC'
  754.              *  se vengono utilizzati keystore P12.
  755.              *  Il codice  
  756.              *      <resource-root path="WEB-INF/lib/bcprov-ext-jdk15on-1.69.jar" use-physical-code-source="true"/>
  757.              *  all'interno del file jboss-deployment-structure.xml non è più sufficiente da quanto è stato necessario
  758.              *  introdurre il codice sottostante 'org.apache.wss4j.dom.engine.WSSConfig.init' 
  759.              *  e di conseguenza tutta la configurazione del modulo 'deployment.custom.javaee.api'
  760.              *  per risolvere il problema java.lang.NoSuchMethodError: org.apache.xml.security.utils.I18n.init 
  761.              */
  762.             // NOTA: il caricamento di BouncyCastleProvider DEVE essere effettuato prima dell'inizializzazione 'org.apache.wss4j.dom.engine.WSSConfig.init' 
  763.             /**Spostato sopra prima del BYOK/HSM
  764.              * if(propertiesReader.isLoadBouncyCastle()){ 
  765.                 ProviderUtils.addBouncyCastleAfterSun(true);
  766.                 OpenSPCoop2Startup.logStartupInfo("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  767.                 
  768.                 if(propertiesReader.getBouncyCastleSecureRandomAlgorithm()!=null) {
  769.                     try{
  770.                         SecureRandom secureRandom = SecureRandom.getInstance(propertiesReader.getBouncyCastleSecureRandomAlgorithm());
  771.                         CryptoServicesRegistrar.setSecureRandom(secureRandom);
  772.                         OpenSPCoop2Startup.logStartupInfo("Aggiunto default SecureRandom '"+secureRandom.getAlgorithm()+"' in CryptoServicesRegistrar di Bouncycastle");
  773.                     }catch(Exception e){
  774.                         this.logError("Inizializzazione SecureRandom in BouncyCastle fallita",e);
  775.                         return;
  776.                     }
  777.                 }
  778.                 else {
  779.                     SecureRandom secureRandom = CryptoServicesRegistrar.getSecureRandom();
  780.                     if(secureRandom!=null) {
  781.                         OpenSPCoop2Startup.logStartupInfo("SecureRandom used in CryptoServicesRegistrar di Bouncycastle: '"+secureRandom.getAlgorithm()+"'");
  782.                     }
  783.                 }               
  784.             }*/
  785.             if(propertiesReader.isUseBouncyCastleProviderForCertificate()) {
  786.                 OpenSPCoop2Startup.logStartupInfo("Add Bouncycastle in CertificateFactory");
  787.                 CertificateFactory.setUseBouncyCastleProvider(true);
  788.             }
  789.             if(propertiesReader.isUseBouncyCastleProviderForMessageDigest()) {
  790.                 OpenSPCoop2Startup.logStartupInfo("Add Bouncycastle in MessageDigestFactory");
  791.                 MessageDigestFactory.setUseBouncyCastleProvider(true);
  792.             }
  793.             if(propertiesReader.isUseBouncyCastleProviderForWss4jCryptoMerlin()) {
  794.                 OpenSPCoop2Startup.logStartupInfo("Add Bouncycastle in keystore.Merlin provider");
  795.                 org.openspcoop2.security.keystore.MerlinProvider.setUseBouncyCastleProvider(true);
  796.             }
  797.             
  798.             DBUtils.setKeystoreJksPasswordRequired(propertiesReader.isConfigurazioneKeystoreJksPasswordRequired());
  799.             DBUtils.setKeystoreJksKeyPasswordRequired(propertiesReader.isConfigurazioneKeystoreJksKeyPasswordRequired());
  800.             DBUtils.setKeystorePkcs12PasswordRequired(propertiesReader.isConfigurazioneKeystorePkcs12PasswordRequired());
  801.             DBUtils.setKeystorePkcs12KeyPasswordRequired(propertiesReader.isConfigurazioneKeystorePkcs12KeyPasswordRequired());
  802.             DBUtils.setTruststoreJksPasswordRequired(propertiesReader.isConfigurazioneTruststoreJksPasswordRequired());
  803.             DBUtils.setTruststorePkcs12PasswordRequired(propertiesReader.isConfigurazioneTruststorePkcs12PasswordRequired());
  804.             // disabilito anche nelle librerie
  805.             if(!propertiesReader.isConfigurazioneKeystoreJksPasswordRequired() || !propertiesReader.isConfigurazioneTruststoreJksPasswordRequired()) {
  806.                 KeyManagementUtils.setKeystoreJksPasswordRequired(false);
  807.             }
  808.             if(!propertiesReader.isConfigurazioneKeystoreJksKeyPasswordRequired()) {
  809.                 KeyManagementUtils.setKeystoreJksKeyPasswordRequired(false);
  810.             }
  811.             if(!propertiesReader.isConfigurazioneKeystorePkcs12PasswordRequired() || !propertiesReader.isConfigurazioneTruststorePkcs12PasswordRequired()) {
  812.                 KeyManagementUtils.setKeystorePkcs12PasswordRequired(false);
  813.             }
  814.             if(!propertiesReader.isConfigurazioneKeystorePkcs12KeyPasswordRequired()) {
  815.                 KeyManagementUtils.setKeystorePkcs12KeyPasswordRequired(false);
  816.             }
  817.             OpenSPCoop2Startup.logStartupInfo("KeyManagementUtils.keystoreJksPasswordRequired="+KeyManagementUtils.isKeystoreJksPasswordRequired());
  818.             OpenSPCoop2Startup.logStartupInfo("KeyManagementUtils.keystoreJksKeyPasswordRequired="+KeyManagementUtils.isKeystoreJksKeyPasswordRequired());
  819.             OpenSPCoop2Startup.logStartupInfo("KeyManagementUtils.keystorePkcs12PasswordRequired="+KeyManagementUtils.isKeystorePkcs12PasswordRequired());
  820.             OpenSPCoop2Startup.logStartupInfo("KeyManagementUtils.keystorePkcs12KeyPasswordRequired="+KeyManagementUtils.isKeystorePkcs12KeyPasswordRequired());
  821.             if(!propertiesReader.isConfigurazioneKeystoreJksPasswordRequired() || !propertiesReader.isConfigurazioneTruststoreJksPasswordRequired() ||
  822.                     !propertiesReader.isConfigurazioneKeystorePkcs12PasswordRequired() || !propertiesReader.isConfigurazioneTruststorePkcs12PasswordRequired()) {
  823.                 WSHandler.setKeystorePasswordRequired(false);
  824.             }
  825.             OpenSPCoop2Startup.logStartupInfo("WSHandler.keystorePasswordRequired="+WSHandler.isKeystorePasswordRequired());
  826.             
  827.             StringBuilder sb = new StringBuilder();
  828.             Provider[] providerList = Security.getProviders();
  829.             sb.append("Security Providers disponibili sono "+providerList.length+":\n");
  830.             for (int i = 0; i < providerList.length; i++) {
  831.                 sb.append("[" + (i + 1) + "] - Name:"+ providerList[i].getName()+"\n");
  832.             }
  833.             OpenSPCoop2Startup.logStartupInfo(sb.toString());
  834.             
  835.             if(propertiesReader.getSecurityEgd()!=null) {
  836.                 System.setProperty("java.security.egd", propertiesReader.getSecurityEgd());
  837.                 OpenSPCoop2Startup.logStartupInfo("Aggiunta proprietà java.security.egd="+propertiesReader.getSecurityEgd());
  838.             }
  839.                         
  840.             /* ------------ 
  841.              * Inizializzazione Resource Bundle:
  842.              * - org/apache/xml/security/resource/xmlsecurity_en.properties (xmlsec-2.3.0.jar)
  843.              * - org/apache/xml/security/resource/xmlsecurity_de.properties (xmlsec-2.3.0.jar)
  844.              * - messages/wss4j_errors.properties (wss4j-ws-security-common-2.4.1.jar)
  845.              * 
  846.              * L'inizializzazione di questa classe DEVE essere all'inizio altrimenti si puo' incorrere in errori tipo il seguente:
  847.              * Caused by: org.apache.wss4j.common.ext.WSSecurityException: No message with ID "noUserCertsFound" found in resource bundle "org/apache/xml/security/resource/xmlsecurity"
  848.              *
  849.              * Il motivo risiede nel fatto che org.apache.wss4j.common.ext.WSSecurityException lancia una eccezione con id "noUserCertsFound".
  850.              * Tale eccezione di fatto estende la classe org/apache/xml/security/exceptions/XMLSecurityException che utilizza il proprio resource bundle
  851.              * per risolvere l'id. Tale classe utilizza normalmente il properties 'org/apache/xml/security/resource/xmlsecurity_en.properties'
  852.              * Mentre l'id 'noUserCertsFound' e' dentro il properties 'messages/wss4j_errors.properties'
  853.              * Pero' xmlsec permette di inizializzare il resource bundle da usare anche grazie ad un metodo dove viene fornito l'intero resource bundle.
  854.              * Questo avviene in xmlsec-2.3.0/src/main/java/org/apache/xml/security/utils/I18n.java metodo init(ResourceBundle resourceBundle)
  855.              * L'inizializzazione avviene pero' solamente una volta. Quindi se qualche altra libreria l'inizializza prima, poi il metodo init diventa una nop.
  856.              * Tale init viene quindi richiamata dalla classe org.apache.wss4j.dom.engine.WSSConfig.init che prepara un resource bundle
  857.              * contenente sia il contenuto originale del properties 'org/apache/xml/security/resource/xmlsecurity_en.properties' che 
  858.              * aggiungendo il contenuto del properties 'messages/wss4j_errors.properties'
  859.              *
  860.              * -------------------- */
  861.             try{
  862.                 org.apache.wss4j.dom.engine.WSSConfig.init();
  863.             }catch(Exception e){
  864.                 this.logError("Inizializzazione org.apache.wss4j.dom.engine.WSSConfig.init",e);
  865.                 return;
  866.             }
  867.             if(propertiesReader.getWsuIdSecureRandomAlgorithm()!=null) {
  868.                 WsuIdAllocator.setSecureRandomAlgorithm(propertiesReader.getWsuIdSecureRandomAlgorithm());
  869.                 OpenSPCoop2Startup.logStartupInfo("SecureRandom used in WsuIdAllocator per WS-Security: '"+propertiesReader.getWsuIdSecureRandomAlgorithm()+"'");
  870.             }
  871.             
  872.             /* ------------ 
  873.              * Disabilita il log di errore prodotto da freemarker
  874.              * https://freemarker.apache.org/docs/api/freemarker/log/Logger.html#SYSTEM_PROPERTY_NAME_LOGGER_LIBRARY
  875.              * deprecato: freemarker.log.Logger.selectLoggerLibrary(freemarker.log.Logger.LIBRARY_NONE);
  876.              */
  877.             try{
  878.                 System.setProperty(freemarker.log.Logger.SYSTEM_PROPERTY_NAME_LOGGER_LIBRARY,freemarker.log.Logger.LIBRARY_NAME_NONE);
  879.             }catch(Exception e){
  880.                 this.logError("Inizializzazione "+freemarker.log.Logger.SYSTEM_PROPERTY_NAME_LOGGER_LIBRARY,e);
  881.                 return;
  882.             }
  883.             
  884.             /* ------------ 
  885.              * Disabilita la cache del motore JsonPath, altrimenti pattern che contengono il 'concat' vengono cachati e se applicati su messaggi differenti ritornano lo stesso risultato.
  886.              */
  887.             try{
  888.                 if(!propertiesReader.isJsonPathCacheEnabled()){ 
  889.                     JsonPathExpressionEngine.disableCacheJsonPathEngine();
  890.                     OpenSPCoop2Startup.logStartupInfo("Disabilitata cache (NOOPCache) in engine com.jayway.jsonpath.spi.cache.CacheProvider (JsonPath)");
  891.                 }
  892.             }catch(Exception e){
  893.                 this.logError("Cache JsonPathEngine disabilitata",e);
  894.                 return;
  895.             }
  896.             
  897.             if(propertiesReader.isHttpDisableKeepAlive()) {
  898.                 /* ------------ 
  899.                  * Disabilita KeepAlive
  900.                  */
  901.                 try{
  902.                     System.setProperty("http.keepAlive","false");
  903.                     OpenSPCoop2Startup.logStartupInfo("Impostazione http.keepAlive=false effettuata");
  904.                 }catch(Exception e){
  905.                     this.logError("Impostazione http.keepAlive=false non riuscita",e);
  906.                     return;
  907.                 }
  908.             }
  909.             
  910.             // Inizializzo Semaphore
  911.             org.openspcoop2.utils.Semaphore.setDefaultLockAcquisitionTimeoutMs(propertiesReader.getSemaphoreTimeoutMS());
  912.             org.openspcoop2.utils.Semaphore.setDefaultLockHoldTimeoutMs(propertiesReader.getSemaphoreHoldTimeoutMS());
  913.             if(propertiesReader.getSemaphoreHoldTimeoutMS()>0) {
  914.                 org.openspcoop2.utils.SemaphoreLock.initScheduledExecutorService();
  915.             }
  916.             org.openspcoop2.utils.Semaphore.setDefaultDebug(propertiesReader.isSemaphoreDebug());
  917.             org.openspcoop2.utils.Semaphore.setSemaphoreType(propertiesReader.getSemaphoreType());
  918.             org.openspcoop2.utils.Semaphore.setFair(propertiesReader.isSemaphoreFair());
  919.             OpenSPCoop2Startup.logStartupInfo("Impostazione semaphore acquisitionTimeoutMs="+org.openspcoop2.utils.Semaphore.getDefaultLockAcquisitionTimeoutMs()+
  920.                     " holdTimeoutMs="+org.openspcoop2.utils.Semaphore.getDefaultLockHoldTimeoutMs()+
  921.                     " scheduledExecutorServiceEnabled="+org.openspcoop2.utils.SemaphoreLock.isInitializedScheduledExecutorService()+
  922.                     " debug="+org.openspcoop2.utils.Semaphore.isDefaultDebug()+
  923.                     " type="+org.openspcoop2.utils.Semaphore.getSemaphoreType()+
  924.                     " fair="+org.openspcoop2.utils.Semaphore.isFair());
  925.             
  926.             // Inizializzo Controlli connessioni
  927.             Logger logR = OpenSPCoop2Logger.getLoggerOpenSPCoopResources()!=null ? OpenSPCoop2Logger.getLoggerOpenSPCoopResources() : log;
  928.             ServicesUtils.initCheckConnectionDB(logR, propertiesReader.isJdbcCloseConnectionCheckIsClosed(), propertiesReader.isJdbcCloseConnectionCheckAutocommit());
  929.             



  933.             /* ------------- Inizializzo il sistema di Logging di OpenSPCoop --------------- */
  934.             boolean isInitializeLogger = false;
  935.             isInitializeLogger = OpenSPCoop2Logger.initialize(OpenSPCoop2Startup.log,propertiesReader.getRootDirectory(),loggerP,
  936.                     propertiesReader.isAllarmiEnabled());
  937.             if(!isInitializeLogger){
  938.                 return;
  939.             }
  940.             Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  941.             OpenSPCoop2Startup.log = LoggerWrapperFactory.getLogger(LOG_CATEGORY_STARTUP);
  942.             
  943.             Utilities.setLog(logCore);
  944.             Utilities.setFreeMemoryLog(propertiesReader.getFreeMemoryLog());
  945.             
  946.             OpenSPCoop2Startup.initializeLog = true;
  947.             
  948.             if(propertiesReader.isLoggerSaajDisabilitato()) {
  949.                 /**java.util.logging.Logger logSaaj = java.util.logging.Logger.getLogger(com.sun.xml.messaging.saaj.util.LogDomainConstants.SOAP_DOMAIN
  950.                                                                                         "com.sun.xml.messaging.saaj.soap.LocalStrings");*/
  951.                 java.util.logging.Logger logSaaj = java.util.logging.Logger.getLogger(com.sun.xml.messaging.saaj.util.LogDomainConstants.MODULE_TOPLEVEL_DOMAIN);
  952.                 logSaaj.setLevel(Level.OFF);
  953.                 logSaaj.severe("Il logger utilizzato nel package '"+com.sun.xml.messaging.saaj.util.LogDomainConstants.MODULE_TOPLEVEL_DOMAIN+"' e' stato disabilitato; questo messaggio non deve essere visualizzato");
  954.                 logSaaj.severe("SAAJ0511.soap.cannot.create.envelope"); // serve per caricare il logger con il local string
  955.                 OpenSPCoop2Startup.logStartupInfo("Il logger utilizzato nel package '"+com.sun.xml.messaging.saaj.util.LogDomainConstants.MODULE_TOPLEVEL_DOMAIN+"' e' stato disabilitato");
  956.             }
  957.             
  958.             RequestThreadContext.setLog(OpenSPCoop2Logger.getLoggerOpenSPCoopConnettori());

  960.             org.openspcoop2.utils.Semaphore.setLogDebug(OpenSPCoop2Logger.getLoggerOpenSPCoopResources());
  961.             
  962.             


  965.             /* ------------- Pdd.properties --------------- */
  966.             String locationPddProperties = null;
  967.             if( propertiesReader.getLocationPddProperties()!=null ){
  968.                 locationPddProperties = propertiesReader.getLocationPddProperties();
  969.             }
  970.             if( !PddProperties.initialize(locationPddProperties,propertiesReader.getRootDirectory())){
  971.                 this.logError("Riscontrato errore durante l'inizializzazione del reader di 'govway.pdd.properties'");
  972.                 return;
  973.             }
  974.             if(o!=null){
  975.                 try{
  976.                     PddProperties.updateLocalImplementation((Properties)o[3]);
  977.                 }catch(Exception e){
  978.                     // ignore
  979.                 }
  980.             }
  981.             try{
  982.                 OpenSPCoop2Properties.updatePddPropertiesReader(PddProperties.getInstance());
  983.             }catch(Exception e){
  984.                 this.logError("Riscontrato errore durante l'assegnamento del pddPropertiesReader a OpenSPCoopPropertiesReader: "+e.getMessage(),e);
  985.                 return;
  986.             }










  997.             /* ------------- MsgDiagnostici.properties --------------- */
  998.             if( !MsgDiagnosticiProperties.initialize(null,propertiesReader.getRootDirectory())){
  999.                 this.logError("Riscontrato errore durante l'inizializzazione del reader di 'govway.msgDiagnostici.properties'");
  1000.                 return;
  1001.             }
  1002.             if(o!=null){
  1003.                 try{
  1004.                     MsgDiagnosticiProperties.updateLocalImplementation((Properties)o[6]);
  1005.                 }catch(Exception e){
  1006.                     // ignore
  1007.                 }
  1008.             }
  1009.             MsgDiagnosticiProperties msgDiagProperties = MsgDiagnosticiProperties.getInstance();
  1010.             if(msgDiagProperties.initializeMsgDiagnosticiPersonalizzati() == false){
  1011.                 return;
  1012.             }





  1018.             
  1019.             
  1020.             
  1021.             /* ------------- Cache.properties --------------- */
  1022.             boolean isInitializeCache = Cache.initialize(OpenSPCoop2Startup.log, logCore, 
  1023.                     CostantiPdD.OPENSPCOOP2_CACHE_DEFAULT_PROPERTIES_NAME,
  1024.                     propertiesReader.getRootDirectory(), cacheP, 
  1025.                     CostantiPdD.OPENSPCOOP2_LOCAL_HOME, CostantiPdD.OPENSPCOOP2_CACHE_PROPERTIES, CostantiPdD.OPENSPCOOP2_CACHE_LOCAL_PATH);
  1026.             if(isInitializeCache == false){
  1027.                 this.logError("Riscontrato errore durante l'inizializzazione della cache di OpenSPCoop.");
  1028.                 return;
  1029.             }
  1030.             
  1031.             
  1032.             
  1033.             
  1034.             /* ------------- Inizializzo Configurazione FileTrace --------------- */
  1035.             try {
  1036.                 if(propertiesReader.isTransazioniFileTraceEnabled()) {
  1037.                     FileTraceConfig.init(propertiesReader.getTransazioniFileTraceConfig(), true);
  1038.                 }
  1039.             }catch(Exception e) {
  1040.                 this.logError("Riscontrato errore durante l'inizializzazione del FileTrace",e);
  1041.                 return;
  1042.             }

  1044.             
  1045.             
  1046.             
  1047.             /* ----------- Inizializzazione Risorse DOM/SOAP ------------ */
  1048.             List<OpenSPCoop2MessageFactory> messageFactory = new ArrayList<>();
  1049.             try{
  1050.                 // TransazioneContext
  1051.                 TransactionContext.initGestioneStateful();
  1052.                 OpenSPCoop2Startup.logStartupInfo("TransactionContext.gestioneStateful: "+propertiesReader.isTransazioniStatefulEnabled());
  1053.                 TransactionContext.initResources();
  1054.                 OpenSPCoop2Startup.logStartupInfo("TransactionContext.type (sync:"+propertiesReader.isConfigurazioneCache_transactionContext_accessiSynchronized()+"): "+TransactionContext.getTransactionContextType());
  1055.                 
  1056.                 // Cache
  1057.                 if(!propertiesReader.isConfigurazioneCache_accessiSynchronized()) {
  1058.                     Cache.disableSyncronizedGetAsDefault();
  1059.                 }
  1060.                 OpenSPCoop2Startup.logStartupInfo("Cache.disableSyncronizedGetAsDefault: "+Cache.isDisableSyncronizedGetAsDefault());
  1061.                 Cache.DEBUG_CACHE=propertiesReader.isConfigurazioneCacheDebug();
  1062.                 OpenSPCoop2Startup.logStartupInfo("Cache.DEBUG: "+Cache.DEBUG_CACHE);
  1063.                 GestoreRichieste.setUseCache(propertiesReader.isConfigurazioneCacheRequestManagerUseCache());
  1064.                 OpenSPCoop2Startup.logStartupInfo("Cache.requestManager.useCache: "+GestoreRichieste.isUseCache());
  1065.                 
  1066.                 
  1067.                 // MessageFactory
  1068.                 OpenSPCoop2MessageFactory.setMessageFactoryImpl(classNameReader.getOpenSPCoop2MessageFactory(propertiesReader.getOpenspcoop2MessageFactory()));
  1069.                 OpenSPCoop2MessageFactory.initDefaultMessageFactory(true);
  1070.                 
  1071.                 // Buffer Dump
  1072.                 if(propertiesReader.getDumpBufferImpl()!=null && !"".equals(propertiesReader.getDumpBufferImpl())) {
  1073.                     DumpByteArrayOutputStream.setClassImpl(propertiesReader.getDumpBufferImpl());
  1074.                 }
  1075.                 OpenSPCoop2Startup.logStartupInfo("DumpByteArrayOutputStream buffer implementation: "+DumpByteArrayOutputStream.getClassImpl());
  1076.                 OpenSPCoop2Startup.logStartupInfo("DumpBinario set buffer threshold: "+propertiesReader.getDumpBinarioInMemoryThreshold());
  1077.                 AbstractBaseOpenSPCoop2MessageDynamicContent.setSoglia(propertiesReader.getDumpBinarioInMemoryThreshold());
  1078.                 OpenSPCoop2Startup.logStartupInfo("DumpBinario set buffer repository: "+propertiesReader.getDumpBinarioRepository());
  1079.                 AbstractBaseOpenSPCoop2MessageDynamicContent.setRepositoryFile(propertiesReader.getDumpBinarioRepository());
  1080.                 
  1081.                 // SoapBuffer
  1082.                 boolean soapReader = propertiesReader.useSoapMessageReader();
  1083.                 OpenSPCoop2Startup.logStartupInfo("SOAPMessageReader enabled="+soapReader);
  1084.                 AbstractBaseOpenSPCoop2MessageDynamicContent.setSoapReader(soapReader);
  1085.                 OpenSPCoop2Startup.logStartupInfo("SOAPMessageReader set buffer threshold (kb): "+propertiesReader.getSoapMessageReaderBufferThresholdKb());
  1086.                 AbstractBaseOpenSPCoop2MessageDynamicContent.setSoapReaderBufferThresholdKb(propertiesReader.getSoapMessageReaderBufferThresholdKb());
  1087.                 if(soapReader) {
  1088.                     OpenSPCoop2Startup.logStartupInfo("SOAPMessageReader headerOptimization enabled="+propertiesReader.useSoapMessageReaderHeaderOptimization());
  1089.                     OpenSPCoop2MessageSoapStreamReader.SOAP_HEADER_OPTIMIZATION_ENABLED=propertiesReader.useSoapMessageReaderHeaderOptimization();
  1090.                 }
  1091.                 
  1092.                 // SoapPassthrough
  1093.                 boolean soapPassthroughImpl = propertiesReader.useSoapMessagePassthrough();
  1094.                 OpenSPCoop2Startup.logStartupInfo("OpenSPCoop2MessageFactory_impl soapPassthroughImpl="+soapPassthroughImpl);
  1095.                 OpenSPCoop2MessageFactory_impl.setSoapPassthroughImpl(soapPassthroughImpl);
  1096.                                 
  1097.                 // Locale SOAPFault String
  1098.                 Locale localeSoapFaultString = propertiesReader.getLocaleSOAPFaultString();
  1099.                 if(localeSoapFaultString!=null) {
  1100.                     OpenSPCoop2Startup.logStartupInfo("Locale SOAPFault String: "+localeSoapFaultString);
  1101.                     SoapUtils.setSoapFaultStringLocale(localeSoapFaultString);
  1102.                 }
  1103.                 
  1104.                 // ContentType per SOAP 1.2 (ulteriori Content-Type oltre a application/soap+xml e application/soap+fastinfoset)
  1105.                 MessageImpl.alternativeAcceptedContentType1_2 = propertiesReader.getAlternativeContentTypeSoap12();
  1106.                 if(MessageImpl.alternativeAcceptedContentType1_2!=null && !MessageImpl.alternativeAcceptedContentType1_2.isEmpty()) {
  1107.                     StringBuilder sbCT = new StringBuilder();
  1108.                     for (String alternativeContentType : MessageImpl.alternativeAcceptedContentType1_2) {
  1109.                         if(sbCT.length()>0) {
  1110.                             sbCT.append(", ");
  1111.                         }
  1112.                         sbCT.append(alternativeContentType);
  1113.                     }
  1114.                     OpenSPCoop2Startup.logStartupInfo("Registrati ulteriori '"+MessageImpl.alternativeAcceptedContentType1_2.size()+"' content-type associabili ai messaggi SOAP 1.2: "+sbCT.toString());
  1115.                     
  1116.                 }
  1117.                 
  1118.                 // DiagnosticInputStream
  1119.                 DiagnosticInputStream.setSetDateEmptyStream(propertiesReader.isConnettoriUseDiagnosticInputStream_setDateEmptyStream());
  1120.                 OpenSPCoop2Startup.logStartupInfo("DiagnosticInputStream isSetDateEmptyStream: "+DiagnosticInputStream.isSetDateEmptyStream());
  1121.                 
  1122.                 // PipeUnblockedStream
  1123.                 if(propertiesReader.getPipedUnblockedStreamClassName()!=null) {
  1124.                     PipedUnblockedStreamFactory.setImplementation(propertiesReader.getPipedUnblockedStreamClassName());
  1125.                 }
  1126.                 
  1127.                 // RestMultipartLazy
  1128.                 AbstractLazyContent.BUILD_LAZY=propertiesReader.useRestMultipartLazy();
  1129.                 OpenSPCoop2Startup.logStartupInfo("OpenSPCoop2Content lazy="+AbstractLazyContent.BUILD_LAZY);
  1130.                 
  1131.                 // MessageSecurity
  1132.                 MessageSecurityFactory.setMessageSecurityContextClassName(classNameReader.getMessageSecurityContext(propertiesReader.getMessageSecurityContext()));
  1133.                 MessageSecurityFactory.setMessageSecurityDigestReaderClassName(classNameReader.getMessageSecurityDigestReader(propertiesReader.getMessageSecurityDigestReader()));
  1134.                 
  1135.                 List<String> tipiMessageFactory = new ArrayList<>();
  1136.                 List<String> classiMessageFactory = new ArrayList<>();
  1137.                 String factoryDefault = "@DEFAULT@";
  1138.                 tipiMessageFactory.add(factoryDefault);
  1139.                 OpenSPCoop2MessageFactory defaultMessageFactory = OpenSPCoop2MessageFactory.getDefaultMessageFactory();
  1140.                 classiMessageFactory.add(defaultMessageFactory.getClass().getName());
  1141.                 messageFactory.add(defaultMessageFactory);
  1142.                 
  1143.                 String [] tmp_tipiMessageFactory = classNameReader.getOpenSPCoop2MessageFactory();
  1144.                 if(tmp_tipiMessageFactory!=null && tmp_tipiMessageFactory.length>0) {
  1145.                     OpenSPCoop2Startup.logStartupInfo("Analizzo "+tmp_tipiMessageFactory.length+" message factories ...");
  1146.                     for (int i = 0; i < tmp_tipiMessageFactory.length; i++) {
  1147.                         String tipo = tmp_tipiMessageFactory[i];
  1148.                         String classe = classNameReader.getOpenSPCoop2MessageFactory(tipo);
  1149.                         if(!classiMessageFactory.contains(classe)) {
  1150.                             OpenSPCoop2MessageFactory factory = (OpenSPCoop2MessageFactory) loader.newInstance(classe);
  1151.                             tipiMessageFactory.add(tipo);
  1152.                             messageFactory.add(factory);
  1153.                             classiMessageFactory.add(classe);
  1154.                             OpenSPCoop2Startup.logStartupInfo("Registrazione '"+tipo+"' corrispondente alla classe '"+classe+"' terminata");
  1155.                         }
  1156.                         else {
  1157.                             OpenSPCoop2Startup.logStartupInfo("Registrazione '"+tipo+"' corrispondente alla classe '"+classe+"' non effettuata. La stessa classe risulta già associata ad altri tipi.");
  1158.                         }
  1159.                     }
  1160.                 }
  1161.                 
  1162.                 AbstractXMLUtils.DISABLE_DTDs = !propertiesReader.isXmlFactoryDTDsEnabled();
  1163.                 OpenSPCoop2Startup.logStartupInfo("XMLUtils - DISABLE_DTDs: "+AbstractXMLUtils.DISABLE_DTDs);
  1164.                 
  1165.                 DynamicUtils.setXsltProcessAsDomSource(propertiesReader.isXsltProcessAsDOMSource());
  1166.                 OpenSPCoop2Startup.logStartupInfo("DynamicUtils - XSLT_PROCESS_AS_DOMSOURCE: "+DynamicUtils.isXsltProcessAsDomSource());
  1167.                 
  1168.                 Properties yamlSnakeLimits = propertiesReader.getYamlSnakeLimits();
  1169.                 if(yamlSnakeLimits!=null && !yamlSnakeLimits.isEmpty()) {
  1170.                     YamlSnakeLimits.initialize(OpenSPCoop2Startup.log, yamlSnakeLimits);
  1171.                 }
  1172.                 
  1173.                 for (int l = 0; l < tipiMessageFactory.size(); l++) {
  1174.                     String tipo = tipiMessageFactory.get(l);
  1175.                     String classe = classiMessageFactory.get(l);
  1176.                     OpenSPCoop2MessageFactory factory = messageFactory.get(l);
  1177.                     
  1178.                     try{
  1179.                     
  1180.                         OpenSPCoop2Startup.logStartupInfo("Inizializzazione '"+tipo+"' corrispondente alla classe '"+classe+"' ... ");
  1181.                     
  1182.                         // XML
  1183.                         org.openspcoop2.message.xml.MessageXMLUtils xmlUtils = org.openspcoop2.message.xml.MessageXMLUtils.getInstance(factory);
  1184.                         // XML - XERCES
  1185.                         xmlUtils.initDocumentBuilderFactory();
  1186.                         xmlUtils.initDatatypeFactory();
  1187.                         xmlUtils.initSAXParserFactory();
  1188. //                      xmlUtils.initXMLEventFactory();
  1189.                         xmlUtils.initSchemaFactory();
  1190.                         // XML - XALAN
  1191.                         xmlUtils.initTransformerFactory();
  1192.                         xmlUtils.initXPathFactory();
  1193.                         // INIT - OTHER
  1194.                         xmlUtils.initCalendarConverter();
  1195.                         
  1196.                         // SOAP
  1197.                         factory.getSoapFactory11();
  1198.                         factory.getSoapFactory12();
  1199.                         factory.getSoapMessageFactory();
  1200.                         
  1201.                         /*
  1202.                          * Le seguenti inizializzazione servono alle varie factory per evitare di scorrere il classloader a cercare i jar che contengono l'implementazione da utilizzare.
  1203.                          * Lo scan del classloader comporta l'apertura dei vari file jar e quindi il decadimento delle performance poichè i thread risultano bloccati sulla chiamata di apertura del jar
  1204.                          * 
  1205.                          * Esempio di stack che riporta il problema:
  1206.                          * java.util.zip.ZipFile.open(Native Method)
  1207.                          * java.util.zip.ZipFile.(ZipFile.java:219)
  1208.                          * ...
  1209.                          * org.apache.catalina.webresources.AbstractArchiveResourceSet.openJarFile(AbstractArchiveResourceSet.java:308)
  1210.                          * org.apache.catalina.webresources.AbstractSingleArchiveResourceSet.getArchiveEntry(AbstractSingleArchiveResourceSet.java:93)
  1211.                          * ....
  1212.                          * org.apache.catalina.webresources.Cache.getResource(Cache.java:69)
  1213.                          * org.apache.catalina.webresources.StandardRoot.getResource(StandardRoot.java:216)
  1214.                          * org.apache.catalina.webresources.StandardRoot.getClassLoaderResource(StandardRoot.java:225)
  1215.                          * org.apache.catalina.loader.WebappClassLoaderBase.getResourceAsStream(WebappClassLoaderBase.java:1067)
  1216.                          * ...
  1217.                          * org.apache.xerces.parsers.SecuritySupport.getResourceAsStream(Unknown Source)
  1218.                          * org.apache.xerces.parsers.ObjectFactory.findJarServiceProvider(Unknown Source)
  1219.                          * org.apache.xerces.parsers.ObjectFactory.createObject(Unknown Source)
  1220.                          * org.apache.xerces.parsers.DOMParser.(Unknown Source)
  1221.                          * org.apache.xerces.jaxp.DocumentBuilderImpl.(Unknown Source)
  1222.                          * org.apache.xerces.jaxp.DocumentBuilderFactoryImpl.newDocumentBuilder(Unknown Source)
  1223.                          * 
  1224.                          * Ogni factory prima di avviare la ricerca dei jar del service provider, dispone di una proprietà java che se valorizzata
  1225.                          * viene usata per istanziare immediatamente il provider con la classe indicata.
  1226.                          **/
  1227.                         System.setProperty("org.apache.xerces.xni.parser.XMLParserConfiguration",org.apache.xerces.parsers.XIncludeAwareParserConfiguration.class.getName());
  1228.                         System.setProperty("javax.xml.transform.TransformerFactory",org.apache.xalan.processor.TransformerFactoryImpl.class.getName());
  1229.                         System.setProperty("javax.xml.xpath.XPathFactory:"+XPathFactory.DEFAULT_OBJECT_MODEL_URI,org.apache.xpath.jaxp.XPathFactoryImpl.class.getName());
  1230.                         System.setProperty("org.apache.xml.dtm.DTMManager",org.apache.xml.dtm.ref.DTMManagerDefault.class.getName());
  1231.                         
  1232.                         // Log
  1233.                         // stampo comunque saaj factory
  1234.                         String factoryClassName = OpenSPCoop2MessageFactory_impl.class.getName()+"";
  1235.                         OpenSPCoop2Startup.logStartupInfo("OpenSPCoop MessageFactory (open:"+factoryClassName.equals(factory.getClass().getName())+"): "+factory.getClass().getName());
  1236.                         if(propertiesReader.isPrintInfoFactory()){
  1237.                             MessageType [] mt = MessageType.values();
  1238.                             for (int i = 0; i < mt.length; i++) {
  1239.                                 OpenSPCoop2Startup.logStartupInfo("OpenSPCoop Message ["+mt[i].name()+"]: "+factory.createEmptyMessage(mt[i],MessageRole.NONE).getClass().getName());   
  1240.                             }
  1241.                             if( factory.getSoapFactory11()!=null)
  1242.                                 OpenSPCoop2Startup.logStartupInfo("SOAP1.1 Factory: "+ factory.getSoapFactory11().getClass().getName());
  1243.                             else
  1244.                                 OpenSPCoop2Startup.logStartupInfo("SOAP1.1 Factory: not implemented");
  1245.                             if(factory.getSoapFactory12()!=null){
  1246.                                 OpenSPCoop2Startup.logStartupInfo("SOAP1.2 Factory: "+ factory.getSoapFactory12().getClass().getName());
  1247.                             }else{
  1248.                                 OpenSPCoop2Startup.logStartupInfo("SOAP1.2 Factory: not implemented");
  1249.                             }
  1250.                             OpenSPCoop2Startup.logStartupInfo("SOAP MessageFactory: "+factory.getSoapMessageFactory().getClass().getName());
  1251.             
  1252.                             // XML - XERCES
  1253.                             OpenSPCoop2Startup.logStartupInfo("XERCES - DocumentFactory: "+xmlUtils.getDocumentBuilderFactory().getClass().getName());
  1254.                             OpenSPCoop2Startup.logStartupInfo("XERCES - DatatypeFactory: "+xmlUtils.getDatatypeFactory().getClass().getName());
  1255.                             OpenSPCoop2Startup.logStartupInfo("XERCES - SAXParserFactory: "+xmlUtils.getSAXParserFactory().getClass().getName());
  1256. //                          OpenSPCoop2Startup.logStartupInfo("XERCES - XMLEventFactory: "+xmlUtils.getXMLEventFactory().getClass().getName());
  1257.                             OpenSPCoop2Startup.logStartupInfo("XERCES - SchemaFactory: "+xmlUtils.getSchemaFactory().getClass().getName());
  1258.                             
  1259.                             // XML - XALAN
  1260.                             OpenSPCoop2Startup.logStartupInfo("XALAN - TransformerFactory: "+xmlUtils.getTransformerFactory().getClass().getName());
  1261.                             OpenSPCoop2Startup.logStartupInfo("XALAN - XPathFactory: "+xmlUtils.getXPathFactory().getClass().getName());

  1263.                         }
  1264.                         if(propertiesReader.isPrintInfoMessageSecurity()){
  1265.                             OpenSPCoop2Startup.logStartupInfo("MessageSecurity Context: "+MessageSecurityFactory.messageSecurityContextImplClass);
  1266.                             OpenSPCoop2Startup.logStartupInfo("MessageSecurity DigestReader: "+MessageSecurityFactory.messageSecurityDigestReaderImplClass);
  1267.                             OpenSPCoop2Startup.logStartupInfo("MessageSecurity (SoapBox) EncryptedDataHeaderBlock: "+factory.createEmptyMessage(MessageType.SOAP_11,MessageRole.NONE).castAsSoap().getEncryptedDataHeaderBlockClass());
  1268.                             OpenSPCoop2Startup.logStartupInfo("MessageSecurity (SoapBox) ProcessPartialEncryptedMessage: "+factory.createEmptyMessage(MessageType.SOAP_11,MessageRole.NONE).castAsSoap().getProcessPartialEncryptedMessageClass());
  1269.                             OpenSPCoop2Startup.logStartupInfo("MessageSecurity (SoapBox) getSignPartialMessageProcessor: "+factory.createEmptyMessage(MessageType.SOAP_11,MessageRole.NONE).castAsSoap().getSignPartialMessageProcessorClass());
  1270.                         }
  1271.                                                 
  1272.                         // Inizializzo Operazioni "Costose"
  1273.                         // Serve per abbassare la latenza del primo messaggio, altrimenti queste operazioni all'interno del metodo di costruzione dell'header costano sui 50ms
  1274.                         OpenSPCoop2Message msgTest = factory.createEmptyMessage(MessageType.SOAP_11, MessageRole.REQUEST);
  1275.                         SOAPHeader hdr = msgTest.castAsSoap().getSOAPHeader();
  1276.                         if(hdr==null){
  1277.                             hdr = msgTest.castAsSoap().getSOAPPart().getEnvelope().addHeader();
  1278.                         }
  1279.                         String namespaceTest = "http://initialize.openspcoop.org/test";
  1280.                         String prefixTest = "op2";
  1281.                         QName nameTest = new QName(namespaceTest, "Prova", prefixTest);
  1282.                         SOAPHeaderElement testHeader = msgTest.castAsSoap().newSOAPHeaderElement(hdr, nameTest);
  1283.                         testHeader.setActor("http://initialize.openspcoop.org/test");
  1284.                         testHeader.setMustUnderstand(true);
  1285.                         SOAPElement eGovIntestazioneMsg = testHeader.addChildElement("Test",prefixTest,namespaceTest);
  1286.                         if(eGovIntestazioneMsg!=null){
  1287.                             eGovIntestazioneMsg.toString();
  1288.                         }
  1289.                     
  1290.                         OpenSPCoop2Startup.logStartupInfo("Inizializzazione '"+tipo+"' corrispondente alla classe '"+classe+"' effettuata");
  1291.                         
  1292.                     } catch(Exception e) {
  1293.                         this.logError("Inizializzazione '"+tipo+"' corrispondente alla classe '"+classe+"' fallita: "+e.getMessage(),e);
  1294.                         return;
  1295.                     }
  1296.                 }
  1297.                                 
  1298.                 // inizializzo cache per gli headers peer
  1299.                 RegexpPeerHeaderDescriptor.initCache(propertiesReader.getHeadersPeerRegexpCacheSize());
  1300.                 
  1301.             } catch(Exception e) {
  1302.                 this.logError("Inizializzazione Message/DOM/SOAP: "+e.getMessage(), e);
  1303.                 return;
  1304.             }
  1305.             
  1306.             
  1307.             
  1308.             
  1309.             





  1315.             /*----------- Inizializzazione DateManager  --------------*/
  1316.             try{
  1317.                 String tipoClass = classNameReader.getDateManager(propertiesReader.getTipoDateManager());
  1318.                 DateManager.initializeDataManager(tipoClass, propertiesReader.getDateManagerProperties(),logCore);
  1319.                 OpenSPCoop2Startup.logStartupInfo("Inizializzazione DateManager: "+propertiesReader.getTipoDateManager());
  1320.                 
  1321.                 DateUtils.setDEFAULT_DATA_ENGINE_TYPE(propertiesReader.getTipoDateTimeFormat());
  1322.                 OpenSPCoop2Startup.logStartupInfo("Inizializzazione DateTimeFormat: "+propertiesReader.getTipoDateTimeFormat());
  1323.             }catch(Exception e){
  1324.                 this.logError("Riscontrato errore durante l'inizializzazione del DataManager: "+e.getMessage(),e);
  1325.                 return;
  1326.             }





  1332.             /* -------------- Inizializzo DBManager --------------- */

  1334.             String erroreDB = null;
  1335.             try{
  1336.                 DBManager.initialize(propertiesReader.getJNDIName_DataSource(),
  1337.                         propertiesReader.getJNDIContext_DataSource());
  1338.             }catch(Exception e){
  1339.                 erroreDB = e.getMessage();
  1340.                 OpenSPCoop2Startup.logStartupInfo("Datasource non inizializzato... riprovo");
  1341.                 //msgDiag.logStartupError(e, "DatabaseManager");
  1342.                 logCore.error(erroreDB,e);
  1343.             }

  1345.             int count = 0;
  1346.             boolean trovato = DBManager.isInitialized();                        
  1347.             while (!trovato && (count < 600000)) {
  1348.                 try {
  1349.                     DBManager.initialize(propertiesReader.getJNDIName_DataSource(),
  1350.                             propertiesReader.getJNDIContext_DataSource());
  1351.                 } catch (Exception e) {
  1352.                     erroreDB = e.getMessage();
  1353.                     OpenSPCoop2Startup.logStartupInfo("Attendo inizializzazione del Datasource ... "+erroreDB);
  1354.                     logCore.error(erroreDB,e);
  1355.                 }

  1357.                 if (DBManager.isInitialized()) {
  1358.                     trovato = true;
  1359.                 } else {
  1360.                     count += 10000;
  1361.                     Utilities.sleep(10000);
  1362.                 }
  1363.             }

  1365.             if (DBManager.isInitialized()) {
  1366.                 OpenSPCoop2Startup.logStartupInfo("Inizializzazione DBManager effettuata con successo.");
  1367.             } else {
  1368.                 OpenSPCoop2Startup.log.error("Inizializzazione DBManager non effettuata", new Exception(erroreDB));
  1369.                 //msgDiag.logStartupError(new Exception(erroreDB), "DatabaseManager");
  1370.                 return;
  1371.             }

  1373.             if( JDBCUtilities.isTransactionIsolationNone(DBManager.getTransactionIsolationLevel()) )
  1374.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is NONE");
  1375.             else if(JDBCUtilities.isTransactionIsolationReadCommitted(DBManager.getTransactionIsolationLevel()) )
  1376.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is READ_COMMITTED");
  1377.             else if(JDBCUtilities.isTransactionIsolationReadUncommitted(DBManager.getTransactionIsolationLevel()) )
  1378.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is READ_UNCOMMITTED");
  1379.             else if(JDBCUtilities.isTransactionIsolationRepeatableRead(DBManager.getTransactionIsolationLevel()) )
  1380.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is REPEATABLE_READ");
  1381.             else if(JDBCUtilities.isTransactionIsolationSerializable(DBManager.getTransactionIsolationLevel()) )
  1382.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is SERIALIZABLE");
  1383.             else if(JDBCUtilities.isTransactionIsolationSqlServerSnapshot(DBManager.getTransactionIsolationLevel()) )
  1384.                 OpenSPCoop2Startup.logStartupInfo("Database TransactionLevel is SQLSERVER SNAPSHOT");
  1385.             else {
  1386.                 OpenSPCoop2Startup.log.error("TransactionLevel associato alla connessione non conosciuto");
  1387.                 //          msgDiag.logStartupError("TransactionLevel associato alla connessione non conosciuto","DatabaseManager");
  1388.                 return;
  1389.             }

  1391.             // Assegno datasource a Libreria per gestione stateless
  1392.             try{
  1393.                 org.openspcoop2.protocol.utils.IDSerialGenerator.init(DBManager.getInstance().getDataSource());
  1394.             }catch(Exception e){
  1395.                 OpenSPCoop2Startup.log.error("Inizializzazione datasource libreria serial generator", e);
  1396.                 //msgDiag.logStartupError(e, "Inizializzazione datasource libreria");
  1397.                 return;
  1398.             }

  1400.             // GestoreTransazioni
  1401.             try{
  1402.                 if(propertiesReader.isTransazioniUsePddRuntimeDatasource()) {
  1403.                     DBTransazioniManager.init(DBManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1404.                 }
  1405.                 else {
  1406.                     DBTransazioniManager.init(propertiesReader.getTransazioniDatasource(), propertiesReader.getTransazioniDatasourceJndiContext(), 
  1407.                             logCore, propertiesReader.getDatabaseType(), 
  1408.                             propertiesReader.isTransazioniDatasourceUseDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1409.                 }
  1410.             }catch(Exception e){
  1411.                 OpenSPCoop2Startup.log.error("Inizializzazione DBTransazioniManager", e);
  1412.                 return;
  1413.             }

  1415.             // GestoreStatistiche
  1416.             try {
  1417.                 if(propertiesReader.isStatisticheGenerazioneEnabled() || propertiesReader.isControlloTrafficoEnabled()){
  1418.                     if(propertiesReader.isStatisticheUsePddRuntimeDatasource()) {
  1419.                         DBStatisticheManager.init(DBManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1420.                     }
  1421.                     else if(propertiesReader.isStatisticheUseTransazioniDatasource()) {
  1422.                         DBStatisticheManager.init(DBTransazioniManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1423.                     }
  1424.                     else {
  1425.                         DBStatisticheManager.init(propertiesReader.getStatisticheDatasource(), propertiesReader.getStatisticheDatasourceJndiContext(), 
  1426.                                 logCore, propertiesReader.getDatabaseType(), 
  1427.                                 propertiesReader.isStatisticheDatasourceUseDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1428.                     }
  1429.                 }
  1430.             }catch(Exception e){
  1431.                 OpenSPCoop2Startup.log.error("Inizializzazione DBStatisticheManager", e);
  1432.                 return;
  1433.             }
  1434.             
  1435.             if(OpenSPCoop2Startup.this.serverJ2EE==false){
  1436.                 if(propertiesReader.isTimerConsegnaContenutiApplicativiAbilitato()){
  1437.             
  1438.                     // GestoreConsegnePreseInCarico - Smistatore
  1439.                     try{
  1440.                         if(propertiesReader.isTimerConsegnaContenutiApplicativi_smistatore_runtime_useRuntimeManager()) {
  1441.                             DBConsegnePreseInCaricoManager.initSmistatore(DBManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1442.                         }
  1443.                         else {
  1444.                             DBConsegnePreseInCaricoManager.initSmistatore(propertiesReader.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource(), propertiesReader.getTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSourceJndiContext(), 
  1445.                                     logCore, propertiesReader.getDatabaseType(), 
  1446.                                     propertiesReader.isTimerConsegnaContenutiApplicativi_smistatore_runtime_dataSource_useDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1447.                         }
  1448.                     }catch(Exception e){
  1449.                         OpenSPCoop2Startup.log.error("Inizializzazione GestoreConsegnePreseInCarico.smistatore", e);
  1450.                         return;
  1451.                     }
  1452.                     
  1453.                     // GestoreConsegnePreseInCarico - Runtime
  1454.                     try{
  1455.                         if(propertiesReader.isTimerConsegnaContenutiApplicativi_runtime_useRuntimeManager()) {
  1456.                             DBConsegnePreseInCaricoManager.initRuntime(DBManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1457.                         }
  1458.                         else {
  1459.                             DBConsegnePreseInCaricoManager.initRuntime(propertiesReader.getTimerConsegnaContenutiApplicativi_runtime_dataSource(), propertiesReader.getTimerConsegnaContenutiApplicativi_runtime_dataSourceJndiContext(), 
  1460.                                     logCore, propertiesReader.getDatabaseType(), 
  1461.                                     propertiesReader.isTimerConsegnaContenutiApplicativi_runtime_dataSource_useDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1462.                         }
  1463.                     }catch(Exception e){
  1464.                         OpenSPCoop2Startup.log.error("Inizializzazione GestoreConsegnePreseInCarico.runtime", e);
  1465.                         return;
  1466.                     }
  1467.                     
  1468.                     // GestoreConsegnePreseInCarico - Transazioni
  1469.                     try{
  1470.                         if(propertiesReader.isTimerConsegnaContenutiApplicativi_transazioni_useTransactionManager()) {
  1471.                             DBConsegnePreseInCaricoManager.initTransazioni(DBTransazioniManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1472.                         }
  1473.                         else {
  1474.                             DBConsegnePreseInCaricoManager.initTransazioni(propertiesReader.getTimerConsegnaContenutiApplicativi_transazioni_dataSource(), propertiesReader.getTimerConsegnaContenutiApplicativi_transazioni_dataSourceJndiContext(), 
  1475.                                     logCore, propertiesReader.getDatabaseType(), 
  1476.                                     propertiesReader.isTimerConsegnaContenutiApplicativi_transazioni_dataSource_useDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1477.                         }
  1478.                     }catch(Exception e){
  1479.                         OpenSPCoop2Startup.log.error("Inizializzazione GestoreConsegnePreseInCarico.transazioni", e);
  1480.                         return;
  1481.                     }
  1482.                     
  1483.                 }
  1484.             }
  1485.             if(propertiesReader.isIntegrationManagerEnabled()) {
  1486.                 // GestoreConsegneMessageBox - Runtime
  1487.                 try{
  1488.                     if(propertiesReader.isIntegrationManager_runtime_useRuntimeManager()) {
  1489.                         DBConsegneMessageBoxManager.initRuntime(DBManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1490.                     }
  1491.                     else if(propertiesReader.isIntegrationManager_runtime_useConsegnePreseInCaricoManager()) {
  1492.                         DBConsegnePreseInCaricoManager instance = DBConsegnePreseInCaricoManager.getInstanceRuntime();
  1493.                         if(instance==null) {
  1494.                             throw new CoreException("DBConsegnePreseInCaricoManager-runtime richiesto dalla configurazione del servizio MessageBox non risulta attivo");
  1495.                         }
  1496.                         DBConsegneMessageBoxManager.initRuntime(instance, logCore, propertiesReader.getDatabaseType());
  1497.                     }
  1498.                     else {
  1499.                         DBConsegneMessageBoxManager.initRuntime(propertiesReader.getIntegrationManager_runtime_dataSource(), propertiesReader.getIntegrationManager_runtime_dataSourceJndiContext(), 
  1500.                                 logCore, propertiesReader.getDatabaseType(), 
  1501.                                 propertiesReader.isIntegrationManager_runtime_dataSource_useDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1502.                     }
  1503.                 }catch(Exception e){
  1504.                     OpenSPCoop2Startup.log.error("Inizializzazione GestoreConsegneMessageBox.runtime", e);
  1505.                     return;
  1506.                 }
  1507.                 
  1508.                 // GestoreConsegneMessageBox - Transazioni
  1509.                 try{
  1510.                     if(propertiesReader.isIntegrationManager_transazioni_useTransactionManager()) {
  1511.                         DBConsegneMessageBoxManager.initTransazioni(DBTransazioniManager.getInstance(), logCore, propertiesReader.getDatabaseType());
  1512.                     }
  1513.                     else if(propertiesReader.isIntegrationManager_transazioni_useConsegnePreseInCaricoManager()) {
  1514.                         DBConsegnePreseInCaricoManager instance = DBConsegnePreseInCaricoManager.getInstanceTransazioni();
  1515.                         if(instance==null) {
  1516.                             throw new CoreException("DBConsegnePreseInCaricoManager-transazioni richiesto dalla configurazione del servizio MessageBox non risulta attivo");
  1517.                         }
  1518.                         DBConsegneMessageBoxManager.initTransazioni(instance, logCore, propertiesReader.getDatabaseType());
  1519.                     }
  1520.                     else {
  1521.                         DBConsegneMessageBoxManager.initTransazioni(propertiesReader.getIntegrationManager_transazioni_dataSource(), propertiesReader.getIntegrationManager_transazioni_dataSourceJndiContext(), 
  1522.                                 logCore, propertiesReader.getDatabaseType(), 
  1523.                                 propertiesReader.isIntegrationManager_transazioni_dataSource_useDBUtils(), propertiesReader.isRisorseJMXAbilitate());
  1524.                     }
  1525.                 }catch(Exception e){
  1526.                     OpenSPCoop2Startup.log.error("Inizializzazione GestoreConsegneMessageBox.transazioni", e);
  1527.                     return;
  1528.                 }
  1529.             }

  1531.             
  1532.             /*----------- Inizializzazione Generatore di ClusterID  --------------*/
  1533.             String clusterID = null;
  1534.             try{
  1535.                 clusterID = propertiesReader.getClusterId(false);
  1536.                 
  1537.                 String tipoGeneratoreClusterID = propertiesReader.getTipoIDManager();
  1538.                 String classClusterID = null;
  1539.                 if(CostantiConfigurazione.NONE.equals(tipoGeneratoreClusterID)){
  1540.                     if(clusterID!=null){
  1541.                         classClusterID = org.openspcoop2.utils.id.ClusterIdentifierGenerator.class.getName();
  1542.                     }
  1543.                 }else{
  1544.                     classClusterID = classNameReader.getUniqueIdentifier(tipoGeneratoreClusterID);
  1545.                 }
  1546.                 
  1547.                 if(classClusterID==null){
  1548.                     UniqueIdentifierManager.disabilitaGenerazioneUID();
  1549.                 }else{
  1550.                     
  1551.                     Object [] paramsObject = null;
  1552.                     List<String> params = propertiesReader.getIDManagerParameters();
  1553.                     if(params!=null && !params.isEmpty()) {
  1554.                         paramsObject = new Object [params.size()];
  1555.                         for (int i = 0; i < params.size(); i++) {
  1556.                             paramsObject[i] = params.get(i);
  1557.                         }
  1558.                     }
  1559.                     else {
  1560.                         if(org.openspcoop2.utils.id.ClusterIdentifierGenerator.class.getName().equals(classClusterID)) {
  1561.                             String idCluster = propertiesReader.getClusterId(false);
  1562.                             if(idCluster!=null) {
  1563.                                 paramsObject = new Object [1];
  1564.                                 paramsObject[0] = idCluster;
  1565.                             }
  1566.                         }
  1567.                     }
  1568.                     UniqueIdentifierManager.inizializzaUniqueIdentifierManager(propertiesReader.useIDManagerWithThreadLocal(),classClusterID,paramsObject);
  1569.                     OpenSPCoop2Startup.logStartupInfo("UUID Generator: "+classClusterID);
  1570.                     
  1571.                     if(propertiesReader.generazioneDateCasualiLogAbilitato()){
  1572.                         GeneratoreCasualeDate.init(propertiesReader.getGenerazioneDateCasualiLogDataInizioIntervallo(), 
  1573.                                 propertiesReader.getGenerazioneDateCasualiLogDataFineIntervallo(),
  1574.                                 OpenSPCoop2Startup.log);
  1575.                         OpenSPCoop2Startup.logStartupInfo("Abilitata generazione date casuali");
  1576.                     }
  1577.                     
  1578.                     // BufferProducer avviato in fondo allo startup
  1579.                 }
  1580.                                 
  1581.             }catch(Exception e){
  1582.                 this.logError("Riscontrato errore durante l'inizializzazione del generatore di identificatori unici: "+e.getMessage(),e);
  1583.                 return;
  1584.             }











  1596.             /* ---------  Inizializzazione Configurazione di OpenSPCoop --------------------- */

  1598.             // Inizializza extended info
  1599.             try{
  1600.                 ExtendedInfoManager.initialize(true, loader, propertiesReader.getExtendedInfoConfigurazione(), 
  1601.                         propertiesReader.getExtendedInfoPortaDelegata(), propertiesReader.getExtendedInfoPortaApplicativa());
  1602.             }catch(Exception e){
  1603.                 this.logError("Riscontrato errore durante l'inizializzazione del componente ExtendedInfoManager: "+e.getMessage(),e);
  1604.                 return;
  1605.             }
  1606.             // Inizializza il file ConfigReader che gestisce la configurazione di OpenSPCoop
  1607.             AccessoConfigurazionePdD accessoConfigurazione = null;
  1608.             try{
  1609.                 accessoConfigurazione = propertiesReader.getAccessoConfigurazionePdD();
  1610.             }catch(Exception e){
  1611.                 this.logError("Riscontrato errore durante la lettura della modalita' di accesso alla configurazione di OpenSPCoop: "+e.getMessage(),e);
  1612.                 return;
  1613.             }
  1614.             boolean isInitializeConfig = ConfigurazionePdDReader.initialize(accessoConfigurazione,logCore,OpenSPCoop2Startup.log,localConfig,
  1615.                     propertiesReader.getJNDIName_DataSource(), false,
  1616.                     propertiesReader.isDSOp2UtilsEnabled(), propertiesReader.isRisorseJMXAbilitate(),
  1617.                     propertiesReader.isConfigurazioneCache_ConfigPrefill(), propertiesReader.getCryptConfigAutenticazioneApplicativi(),
  1618.                     propertiesReader.getCacheTypeConfig());
  1619.             if(!isInitializeConfig){
  1620.                 this.logError("Riscontrato errore durante l'inizializzazione della configurazione di OpenSPCoop.");
  1621.                 return;
  1622.             }
  1623.             ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  1624.             if(msgDiagProperties.checkValoriFiltriMsgDiagnostici(OpenSPCoop2Startup.log)==false){
  1625.                 return;
  1626.             }
  1627.             OpenSPCoop2Startup.logStartupInfo("ConfigurazionePdD, refresh: "+propertiesReader.isConfigurazioneDinamica());





  1633.             
  1634.             
  1635.             /*----------- Inizializzazione Configurazione Cluster Dinamica --------------*/
  1636.             try{
  1637.                 if(propertiesReader.isClusterDinamico()) {
  1638.                     if(propertiesReader.isUseHashClusterId()) {
  1639.                         propertiesReader.updateClusterId();
  1640.                     }
  1641.                     OpenSPCoop2Startup.logStartupInfo("Nodo avviato in modalità cluster dinamica con identificativo '"+propertiesReader.getClusterId(false)+"' ("+propertiesReader.getCluster_id_preCodificaHash()+")");
  1642.                     
  1643.                     // aggiorno
  1644.                     clusterID = propertiesReader.getClusterId(false);
  1645.                 }
  1646.                 
  1647.                 boolean rateLimitingGestioneCluster = false;
  1648.                 if(propertiesReader.isControlloTrafficoEnabled()) {
  1649.                     List<PolicyGroupByActiveThreadsType> list = configurazionePdDManager.getTipiGestoreRateLimiting();
  1650.                     rateLimitingGestioneCluster = list!=null && list.contains(PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES);
  1651.                 }
  1652.                 
  1653.                 if(propertiesReader.isClusterDinamico() || rateLimitingGestioneCluster) {   
  1654.                     DynamicClusterManager.initStaticInstance();
  1655.                     DynamicClusterManager.getInstance().setRateLimitingGestioneCluster(rateLimitingGestioneCluster);
  1656.                     DynamicClusterManager.getInstance().register(OpenSPCoop2Startup.log);
  1657.                 }
  1658.             }catch(Exception e){
  1659.                 this.logError("Riscontrato errore durante l'inizializzazione della configurazione relativa al cluster dinamico: "+e.getMessage(),e);
  1660.                 return;
  1661.             }
  1662.             
  1663.             
  1664.             




  1669.             /*----------- Inizializzazione libreria --------------*/
  1670.             try{
  1671.                 IGestoreRepository repository = null;
  1672.                 // Il tipo deve sempre essere letto da openspcoop.properties, altrimenti la testsuite che richiede il tipo di default non viene mai eseguita.
  1673.                 String tipoClass = classNameReader.getRepositoryBuste(propertiesReader.getGestoreRepositoryBuste());
  1674.                 repository = (IGestoreRepository) loader.newInstance(tipoClass);
  1675.                 org.openspcoop2.protocol.engine.Configurazione.init(
  1676.                         propertiesReader.getGestioneSerializableDBCheckInterval(),
  1677.                         repository,propertiesReader.getDatabaseType(),logCore);
  1678.             }catch(Exception e){
  1679.                 this.logError("Riscontrato errore durante l'inizializzazione della libreria del protocollo: "+e.getMessage());
  1680.                 logCore.error("Riscontrato errore durante l'inizializzazione della libreria del protocollo: "+e.getMessage(),e);
  1681.                 return;
  1682.             }









  1692.             /* -------------- Inizializzo MsgDiagnostico -------------------- */
  1693.             MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(OpenSPCoop2Startup.ID_MODULO);


  1696.             
  1697.             
  1698.             
  1699.             
  1700.             
  1701.             
  1702.             /* -------------- Creazione lock entry non esistenti -------------------- */
  1703.             if(!TimerUtils.createEmptyLockTimers(propertiesReader, ID_MODULO, OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), true)) {
  1704.                 msgDiag.logStartupError("Inizializzazione lock per i timer fallita","Inizializzazione Lock");
  1705.                 return;
  1706.             }
  1707.             
  1708.             /* -------------- Rilascio lock -------------------- */
  1709.             // Il rilascio serve a ripulire eventuali lock presi e non rilasciati durante lo shutdown, poiche' la connessione non era piu' disponibile o vi e' stato un kill
  1710.             TimerUtils.relaseLockTimers(propertiesReader, ID_MODULO, OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), true);
  1711.             
  1712.             
  1713.             
  1714.             
  1715.             
  1716.             
  1717.             
  1718.             
  1719.             
  1720.             
  1721.             
  1722.             
  1723.             /*----------- Inizializzazione SystemProperties --------------*/
  1724.             try{
  1725.                 SystemPropertiesManager spm = new SystemPropertiesManager(configurazionePdDManager,logCore);
  1726.                 spm.updateSystemProperties();
  1727.             }catch(Exception e){
  1728.                 msgDiag.logStartupError(e,"Inizializzazione proprieta' di sistema");
  1729.                 return;
  1730.             }
  1731.             
  1732.             
  1733.             
  1734.             
  1735.             
  1736.             
  1737.             /*----------- Inizializzazione Autorizzazione --------------*/
  1738.             try{
  1739.                 AccessoDatiAutorizzazione datiAutorizzazione = configurazionePdDManager.getAccessoDatiAutorizzazione();
  1740.                 if(datiAutorizzazione!=null && datiAutorizzazione.getCache()!=null){
  1741.                     
  1742.                     int dimensioneCache = -1;
  1743.                     if(datiAutorizzazione.getCache().getDimensione()!=null){
  1744.                         try{
  1745.                             dimensioneCache = Integer.parseInt(datiAutorizzazione.getCache().getDimensione());
  1746.                         }catch(Exception e){
  1747.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai dati di autorizzazione");
  1748.                         }
  1749.                     }
  1750.                     
  1751.                     String algoritmo = null;
  1752.                     if(datiAutorizzazione.getCache().getAlgoritmo()!=null){
  1753.                         algoritmo = datiAutorizzazione.getCache().getAlgoritmo().toString();
  1754.                     }
  1755.                     
  1756.                     long idleTime = -1;
  1757.                     if(datiAutorizzazione.getCache().getItemIdleTime()!=null){
  1758.                         try{
  1759.                             idleTime = Integer.parseInt(datiAutorizzazione.getCache().getItemIdleTime());
  1760.                         }catch(Exception e){
  1761.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai dati di autorizzazione");
  1762.                         }
  1763.                     }
  1764.                     
  1765.                     long itemLifeSecond = -1;
  1766.                     if(datiAutorizzazione.getCache().getItemLifeSecond()!=null){
  1767.                         try{
  1768.                             itemLifeSecond = Integer.parseInt(datiAutorizzazione.getCache().getItemLifeSecond());
  1769.                         }catch(Exception e){
  1770.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai dati di autorizzazione");
  1771.                         }
  1772.                     }

  1774.                     GestoreAutorizzazione.initialize(propertiesReader.getCacheTypeAuthorization(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  1775.                 }
  1776.                 else{
  1777.                     GestoreAutorizzazione.initialize(logCore);
  1778.                 }
  1779.             }catch(Exception e){
  1780.                 msgDiag.logStartupError(e,"Gestore Autorizzazione");
  1781.                 return;
  1782.             }
  1783.             
  1784.             
  1785.             
  1786.             
  1787.             
  1788.             /*----------- Inizializzazione Autenticazione --------------*/
  1789.             try{
  1790.                 AccessoDatiAutenticazione datiAutenticazione = configurazionePdDManager.getAccessoDatiAutenticazione();
  1791.                 if(datiAutenticazione!=null && datiAutenticazione.getCache()!=null){
  1792.                     
  1793.                     int dimensioneCache = -1;
  1794.                     if(datiAutenticazione.getCache().getDimensione()!=null){
  1795.                         try{
  1796.                             dimensioneCache = Integer.parseInt(datiAutenticazione.getCache().getDimensione());
  1797.                         }catch(Exception e){
  1798.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai dati di autenticazione");
  1799.                         }
  1800.                     }
  1801.                     
  1802.                     String algoritmo = null;
  1803.                     if(datiAutenticazione.getCache().getAlgoritmo()!=null){
  1804.                         algoritmo = datiAutenticazione.getCache().getAlgoritmo().toString();
  1805.                     }
  1806.                     
  1807.                     long idleTime = -1;
  1808.                     if(datiAutenticazione.getCache().getItemIdleTime()!=null){
  1809.                         try{
  1810.                             idleTime = Integer.parseInt(datiAutenticazione.getCache().getItemIdleTime());
  1811.                         }catch(Exception e){
  1812.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai dati di autenticazione");
  1813.                         }
  1814.                     }
  1815.                     
  1816.                     long itemLifeSecond = -1;
  1817.                     if(datiAutenticazione.getCache().getItemLifeSecond()!=null){
  1818.                         try{
  1819.                             itemLifeSecond = Integer.parseInt(datiAutenticazione.getCache().getItemLifeSecond());
  1820.                         }catch(Exception e){
  1821.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai dati di autenticazione");
  1822.                         }
  1823.                     }

  1825.                     GestoreAutenticazione.initialize(propertiesReader.getCacheTypeAuthentication(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  1826.                 }
  1827.                 else{
  1828.                     GestoreAutenticazione.initialize(logCore);
  1829.                 }
  1830.             }catch(Exception e){
  1831.                 msgDiag.logStartupError(e,"Gestore Autenticazione");
  1832.                 return;
  1833.             }
  1834.             
  1835.             
  1836.             
  1837.             
  1838.             
  1839.             
  1840.             /*----------- Inizializzazione GestoreToken --------------*/
  1841.             try{
  1842.                 AccessoDatiGestioneToken datiGestioneToken = configurazionePdDManager.getAccessoDatiGestioneToken();
  1843.                 if(datiGestioneToken!=null && datiGestioneToken.getCache()!=null){
  1844.                     
  1845.                     int dimensioneCache = -1;
  1846.                     if(datiGestioneToken.getCache().getDimensione()!=null){
  1847.                         try{
  1848.                             dimensioneCache = Integer.parseInt(datiGestioneToken.getCache().getDimensione());
  1849.                         }catch(Exception e){
  1850.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai dati dei token");
  1851.                         }
  1852.                     }
  1853.                     
  1854.                     String algoritmo = null;
  1855.                     if(datiGestioneToken.getCache().getAlgoritmo()!=null){
  1856.                         algoritmo = datiGestioneToken.getCache().getAlgoritmo().toString();
  1857.                     }
  1858.                     
  1859.                     long idleTime = -1;
  1860.                     if(datiGestioneToken.getCache().getItemIdleTime()!=null){
  1861.                         try{
  1862.                             idleTime = Integer.parseInt(datiGestioneToken.getCache().getItemIdleTime());
  1863.                         }catch(Exception e){
  1864.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai dati dei token");
  1865.                         }
  1866.                     }
  1867.                     
  1868.                     long itemLifeSecond = -1;
  1869.                     if(datiGestioneToken.getCache().getItemLifeSecond()!=null){
  1870.                         try{
  1871.                             itemLifeSecond = Integer.parseInt(datiGestioneToken.getCache().getItemLifeSecond());
  1872.                         }catch(Exception e){
  1873.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai dati dei token");
  1874.                         }
  1875.                     }

  1877.                     GestoreToken.initializeGestioneToken(propertiesReader.getCacheTypeToken(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  1878.                 }
  1879.                 else{
  1880.                     GestoreToken.initializeGestioneToken(logCore);
  1881.                 }
  1882.             }catch(Exception e){
  1883.                 msgDiag.logStartupError(e,"Gestore Token");
  1884.                 return;
  1885.             }
  1886.             
  1887.             
  1888.             
  1889.             
  1890.             
  1891.             
  1892.             /*----------- Inizializzazione AttributeAuthority --------------*/
  1893.             try{
  1894.                 AccessoDatiAttributeAuthority datiAttributeAuthority = configurazionePdDManager.getAccessoDatiAttributeAuthority();
  1895.                 if(datiAttributeAuthority!=null && datiAttributeAuthority.getCache()!=null){
  1896.                     
  1897.                     int dimensioneCache = -1;
  1898.                     if(datiAttributeAuthority.getCache().getDimensione()!=null){
  1899.                         try{
  1900.                             dimensioneCache = Integer.parseInt(datiAttributeAuthority.getCache().getDimensione());
  1901.                         }catch(Exception e){
  1902.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai dati dei token");
  1903.                         }
  1904.                     }
  1905.                     
  1906.                     String algoritmo = null;
  1907.                     if(datiAttributeAuthority.getCache().getAlgoritmo()!=null){
  1908.                         algoritmo = datiAttributeAuthority.getCache().getAlgoritmo().toString();
  1909.                     }
  1910.                     
  1911.                     long idleTime = -1;
  1912.                     if(datiAttributeAuthority.getCache().getItemIdleTime()!=null){
  1913.                         try{
  1914.                             idleTime = Integer.parseInt(datiAttributeAuthority.getCache().getItemIdleTime());
  1915.                         }catch(Exception e){
  1916.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai dati dei token");
  1917.                         }
  1918.                     }
  1919.                     
  1920.                     long itemLifeSecond = -1;
  1921.                     if(datiAttributeAuthority.getCache().getItemLifeSecond()!=null){
  1922.                         try{
  1923.                             itemLifeSecond = Integer.parseInt(datiAttributeAuthority.getCache().getItemLifeSecond());
  1924.                         }catch(Exception e){
  1925.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai dati dei token");
  1926.                         }
  1927.                     }

  1929.                     GestoreToken.initializeAttributeAuthority(propertiesReader.getCacheTypeAttributeAuthority(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  1930.                 }
  1931.                 else{
  1932.                     GestoreToken.initializeAttributeAuthority(logCore);
  1933.                 }
  1934.             }catch(Exception e){
  1935.                 msgDiag.logStartupError(e,"AttributeAuthority");
  1936.                 return;
  1937.             }
  1938.             
  1939.             
  1940.             
  1941.             
  1942.             
  1943.             
  1944.             
  1945.             
  1946.             /*----------- Inizializzazione ResponseCaching --------------*/
  1947.             try{
  1948.                 GestoreCacheResponseCaching.initialize();
  1949.                 
  1950.                 org.openspcoop2.core.config.Cache responseCachingCacheConfig = configurazionePdDManager.getConfigurazioneResponseCachingCache();
  1951.                 if(responseCachingCacheConfig!=null){
  1952.                     
  1953.                     int dimensioneCache = -1;
  1954.                     if(responseCachingCacheConfig.getDimensione()!=null){
  1955.                         try{
  1956.                             dimensioneCache = Integer.parseInt(responseCachingCacheConfig.getDimensione());
  1957.                         }catch(Exception e){
  1958.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di response caching");
  1959.                         }
  1960.                     }
  1961.                     
  1962.                     String algoritmo = null;
  1963.                     if(responseCachingCacheConfig.getAlgoritmo()!=null){
  1964.                         algoritmo = responseCachingCacheConfig.getAlgoritmo().toString();
  1965.                     }
  1966.                     
  1967.                     long idleTime = -1;
  1968.                     if(responseCachingCacheConfig.getItemIdleTime()!=null){
  1969.                         try{
  1970.                             idleTime = Integer.parseInt(responseCachingCacheConfig.getItemIdleTime());
  1971.                         }catch(Exception e){
  1972.                             throw new CoreException("Parametro 'idleTime' errato per la cache di response caching");
  1973.                         }
  1974.                     }
  1975.                     
  1976.                     long itemLifeSecond = -1;
  1977.                     if(responseCachingCacheConfig.getItemLifeSecond()!=null){
  1978.                         try{
  1979.                             itemLifeSecond = Integer.parseInt(responseCachingCacheConfig.getItemLifeSecond());
  1980.                         }catch(Exception e){
  1981.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di response caching");
  1982.                         }
  1983.                     }

  1985.                     GestoreCacheResponseCaching.initialize(propertiesReader.getCacheTypeResponseCaching(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  1986.                 }
  1987.                 else{
  1988.                     GestoreCacheResponseCaching.initialize(logCore);
  1989.                 }
  1990.             }catch(Exception e){
  1991.                 msgDiag.logStartupError(e,"Gestore Response Caching");
  1992.                 return;
  1993.             }
  1994.             
  1995.             
  1996.             
  1997.             
  1998.             
  1999.             
  2000.             
  2001.             
  2002.             
  2003.             
  2004.             
  2005.             
  2006.             /* ----------- Inizializzazione Keystore Security ------------ */
  2007.             
  2008.             try{
  2009.                 AccessoDatiKeystore keystoreCacheConfig = configurazionePdDManager.getAccessoDatiKeystore();
  2010.                 if(keystoreCacheConfig!=null && keystoreCacheConfig.getCache()!=null){
  2011.                     
  2012.                     int dimensioneCache = -1;
  2013.                     if(keystoreCacheConfig.getCache().getDimensione()!=null){
  2014.                         try{
  2015.                             dimensioneCache = Integer.parseInt(keystoreCacheConfig.getCache().getDimensione());
  2016.                         }catch(Exception e){
  2017.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai keystore");
  2018.                         }
  2019.                     }
  2020.                     
  2021.                     String algoritmo = null;
  2022.                     if(keystoreCacheConfig.getCache().getAlgoritmo()!=null){
  2023.                         algoritmo = keystoreCacheConfig.getCache().getAlgoritmo().toString();
  2024.                     }
  2025.                     
  2026.                     long idleTime = -1;
  2027.                     if(keystoreCacheConfig.getCache().getItemIdleTime()!=null){
  2028.                         try{
  2029.                             idleTime = Integer.parseInt(keystoreCacheConfig.getCache().getItemIdleTime());
  2030.                         }catch(Exception e){
  2031.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai keystore");
  2032.                         }
  2033.                     }
  2034.                     
  2035.                     long itemLifeSecond = -1;
  2036.                     if(keystoreCacheConfig.getCache().getItemLifeSecond()!=null){
  2037.                         try{
  2038.                             itemLifeSecond = Integer.parseInt(keystoreCacheConfig.getCache().getItemLifeSecond());
  2039.                         }catch(Exception e){
  2040.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai keystore");
  2041.                         }
  2042.                     }
  2043.                     
  2044.                     long itemCrlLifeSecond = -1;
  2045.                     if(keystoreCacheConfig.getCrlItemLifeSecond()!=null){
  2046.                         try{
  2047.                             itemCrlLifeSecond = Integer.parseInt(keystoreCacheConfig.getCrlItemLifeSecond());
  2048.                         }catch(Exception e){
  2049.                             throw new CoreException("Parametro 'itemCrlLifeSecond' errato per la cache di accesso ai keystore");
  2050.                         }
  2051.                     }

  2053.                     GestoreKeystoreCaching.initialize(propertiesReader.getCacheTypeKeystore(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  2054.                     
  2055.                     if(itemCrlLifeSecond>0) {
  2056.                         GestoreKeystoreCaching.setCacheCrlLifeSeconds(itemCrlLifeSecond);
  2057.                     }
  2058.                 }
  2059.                 else{
  2060.                     GestoreKeystoreCaching.initialize(logCore);
  2061.                     
  2062.                     // Provo ad utilizzare la cache alternativa in memoria
  2063.                     GestoreKeystoreCache.setKeystoreCacheParameters(propertiesReader.isAbilitataCacheMessageSecurityKeystore(),
  2064.                             propertiesReader.getItemLifeSecondCacheMessageSecurityKeystore(), 
  2065.                             propertiesReader.getDimensioneCacheMessageSecurityKeystore());
  2066.                     OpenSPCoop2Startup.logStartupInfo("MessageSecurity Keystore Cache In-Memory enabled["+propertiesReader.isAbilitataCacheMessageSecurityKeystore()+"] itemLifeSecond["+
  2067.                             propertiesReader.getItemLifeSecondCacheMessageSecurityKeystore()+"] size["+
  2068.                             propertiesReader.getDimensioneCacheMessageSecurityKeystore()+"]");
  2069.                     
  2070.                 }
  2071.             }catch(Exception e){
  2072.                 msgDiag.logStartupError(e,"Gestore Keystore Caching");
  2073.                 return;
  2074.             }
  2075.             
  2076.             
  2077.             
  2078.             
  2079.             
  2080.             
  2081.             
  2082.             
  2083.             
  2084.             /*----------- Inizializzazione Cache per Consegna Applicativi --------------*/
  2085.             // Viene fatta prima, perchè questi valori vengono letti dalle inforamzioni JMX sotto.
  2086.             try{
  2087.                 org.openspcoop2.core.config.Cache consegnaApplicativiCacheConfig = configurazionePdDManager.getConfigurazioneConsegnaApplicativiCache();
  2088.                 if(consegnaApplicativiCacheConfig!=null){
  2089.                     
  2090.                     int dimensioneCache = -1;
  2091.                     if(consegnaApplicativiCacheConfig.getDimensione()!=null){
  2092.                         try{
  2093.                             dimensioneCache = Integer.parseInt(consegnaApplicativiCacheConfig.getDimensione());
  2094.                         }catch(Exception e){
  2095.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di response caching");
  2096.                         }
  2097.                     }
  2098.                     
  2099.                     String algoritmo = null;
  2100.                     if(consegnaApplicativiCacheConfig.getAlgoritmo()!=null){
  2101.                         algoritmo = consegnaApplicativiCacheConfig.getAlgoritmo().toString();
  2102.                     }
  2103.                     
  2104.                     long idleTime = -1;
  2105.                     if(consegnaApplicativiCacheConfig.getItemIdleTime()!=null){
  2106.                         try{
  2107.                             idleTime = Integer.parseInt(consegnaApplicativiCacheConfig.getItemIdleTime());
  2108.                         }catch(Exception e){
  2109.                             throw new CoreException("Parametro 'idleTime' errato per la cache di response caching");
  2110.                         }
  2111.                     }
  2112.                     
  2113.                     long itemLifeSecond = -1;
  2114.                     if(consegnaApplicativiCacheConfig.getItemLifeSecond()!=null){
  2115.                         try{
  2116.                             itemLifeSecond = Integer.parseInt(consegnaApplicativiCacheConfig.getItemLifeSecond());
  2117.                         }catch(Exception e){
  2118.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di response caching");
  2119.                         }
  2120.                     }

  2122.                     GestoreLoadBalancerCaching.initialize(propertiesReader.getCacheTypeLoadBalancer(), dimensioneCache, algoritmo, idleTime, itemLifeSecond, logCore);
  2123.                 }
  2124.                 else{
  2125.                     GestoreLoadBalancerCaching.initialize(logCore);
  2126.                 }
  2127.             }catch(Exception e){
  2128.                 msgDiag.logStartupError(e,"Gestore Consegna Applicativi Cache");
  2129.                 return;
  2130.             }
  2131.             
  2132.             
  2133.             
  2134.             
  2135.             
  2136.             
  2137.             
  2138.             
  2139.             
  2140.             /* ----------- Inizializzazione Gestore Richieste ------------ */
  2141.             
  2142.             try{
  2143.                 AccessoDatiRichieste gestoreRichiesteCacheConfig = configurazionePdDManager.getAccessoDatiRichieste();
  2144.                 if(gestoreRichiesteCacheConfig!=null && gestoreRichiesteCacheConfig.getCache()!=null){
  2145.                     
  2146.                     int dimensioneCache = -1;
  2147.                     if(gestoreRichiesteCacheConfig.getCache().getDimensione()!=null){
  2148.                         try{
  2149.                             dimensioneCache = Integer.parseInt(gestoreRichiesteCacheConfig.getCache().getDimensione());
  2150.                         }catch(Exception e){
  2151.                             throw new CoreException("Parametro 'dimensioneCache' errato per la cache di accesso ai dati delle richieste");
  2152.                         }
  2153.                     }
  2154.                     
  2155.                     String algoritmo = null;
  2156.                     if(gestoreRichiesteCacheConfig.getCache().getAlgoritmo()!=null){
  2157.                         algoritmo = gestoreRichiesteCacheConfig.getCache().getAlgoritmo().toString();
  2158.                     }
  2159.                     
  2160.                     long idleTime = -1;
  2161.                     if(gestoreRichiesteCacheConfig.getCache().getItemIdleTime()!=null){
  2162.                         try{
  2163.                             idleTime = Integer.parseInt(gestoreRichiesteCacheConfig.getCache().getItemIdleTime());
  2164.                         }catch(Exception e){
  2165.                             throw new CoreException("Parametro 'idleTime' errato per la cache di accesso ai dati delle richieste");
  2166.                         }
  2167.                     }
  2168.                     
  2169.                     long itemLifeSecond = -1;
  2170.                     if(gestoreRichiesteCacheConfig.getCache().getItemLifeSecond()!=null){
  2171.                         try{
  2172.                             itemLifeSecond = Integer.parseInt(gestoreRichiesteCacheConfig.getCache().getItemLifeSecond());
  2173.                         }catch(Exception e){
  2174.                             throw new CoreException("Parametro 'itemLifeSecond' errato per la cache di accesso ai dati delle richieste");
  2175.                         }
  2176.                     }
  2177.                     
  2178.                     GestoreRichieste.initCacheGestoreRichieste(propertiesReader.getCacheTypeRequestManager(), dimensioneCache, algoritmo,
  2179.                             idleTime, itemLifeSecond, logCore);
  2180.                     
  2181.                 }
  2182.                 else{
  2183.                     GestoreRichieste.initialize(logCore);                   
  2184.                 }
  2185.                 
  2186.                 
  2187.                 RequestConfig.setUseCacheForExternalResource(propertiesReader.isConfigurazioneCacheRequestManagerExternalResourceSaveInCache());
  2188.                 OpenSPCoop2Startup.logStartupInfo("RequestConfig, useCacheForExternalResource: "+RequestConfig.isUseCacheForExternalResource());
  2189.                 
  2190.                 RequestConfig.setUseCacheForOCSPResponse(propertiesReader.isConfigurazioneCacheRequestManagerOCSPResponseSaveInCache());
  2191.                 OpenSPCoop2Startup.logStartupInfo("RequestConfig, useCacheForOCSPResponse: "+RequestConfig.isUseCacheForOCSPResponse());
  2192.                 
  2193.                 RequestConfig.setUseCacheForRemoteStore(propertiesReader.isConfigurazioneCacheRequestManagerRemoteStoreSaveInCache());
  2194.                 OpenSPCoop2Startup.logStartupInfo("RequestConfig, useCacheForRemoteStore: "+RequestConfig.isUseCacheForRemoteStore());
  2195.                 
  2196.                 
  2197.             }catch(Exception e){
  2198.                 msgDiag.logStartupError(e,"Gestore DatiRichieste Caching");
  2199.                 return;
  2200.             }
  2201.             
  2202.             
  2203.             
  2204.             
  2205.             
  2206.             
  2207.             
  2208.             
  2209.             
  2210.             
  2211.             
  2212.             
  2213.             
  2214.             /* ----------- Inizializzazione Gestore Risorse JMX (le risorse jmx vengono registrate in seguito) ------------ */
  2215.             try{
  2216.                 if(propertiesReader.isRisorseJMXAbilitate()){
  2217.                     if(propertiesReader.getJNDIName_MBeanServer()!=null){
  2218.                         OpenSPCoop2Startup.this.gestoreRisorseJMX = new GestoreRisorseJMXGovWay(propertiesReader.getJNDIName_MBeanServer(),
  2219.                                 propertiesReader.getJNDIContext_MBeanServer());
  2220.                     }else{
  2221.                         OpenSPCoop2Startup.this.gestoreRisorseJMX = new GestoreRisorseJMXGovWay();
  2222.                     }
  2223.                     OpenSPCoop2Startup.gestoreRisorseJMX_staticInstance = OpenSPCoop2Startup.this.gestoreRisorseJMX;
  2224.                 }
  2225.             }catch(Exception e){
  2226.                 msgDiag.logStartupError(e,"Gestore Risorse JMX");
  2227.                 return;
  2228.             }
  2229.             
  2230.             
  2231.             
  2232.             
  2233.             
  2234.             
  2235.             
  2236.             

  2238.             
  2239.             
  2240.             /* ------------- Inizializzazione Protocolli ----------- */
  2241.             ProtocolFactoryManager protocolFactoryManager = null;
  2242.             try{
  2243.                 ConfigurazionePdD configPdD = new ConfigurazionePdD();
  2244.                 configPdD.setConfigurationDir(propertiesReader.getRootDirectory());
  2245.                 configPdD.setLoader(loader);
  2246.                 configPdD.setAttesaAttivaJDBC(propertiesReader.getGestioneSerializableDBAttesaAttiva());
  2247.                 configPdD.setCheckIntervalJDBC(propertiesReader.getGestioneSerializableDBCheckInterval());
  2248.                 configPdD.setTipoDatabase(TipiDatabase.toEnumConstant(propertiesReader.getDatabaseType()));
  2249.                 configPdD.setLog(logCore);
  2250.                 
  2251.                 Costanti.initHTTP_HEADER_GOVWAY_ERROR_STATUS(propertiesReader.getErroriHttpHeaderGovWayStatus());
  2252.                 Costanti.initHTTP_HEADER_GOVWAY_ERROR_TYPE(propertiesReader.getErroriHttpHeaderGovWayType());
  2253.                 Costanti.initHTTP_HEADER_GOVWAY_ERROR_CODE(propertiesReader.getErroriHttpHeaderGovWayCode());
  2254.                 
  2255.                 Costanti.setTRANSACTION_ERROR_SOAP_USE_GOVWAY_STATUS_AS_FAULT_CODE(propertiesReader.isErroriSoapUseGovWayStatusAsFaultCode());
  2256.                 Costanti.setTRANSACTION_ERROR_SOAP_GENERATE_HTTP_HEADER_GOVWAY_CODE(propertiesReader.isErroriSoapHttpHeaderGovWayCodeEnabled());
  2257.                                 
  2258.                 Costanti.setTRANSACTION_ERROR_STATUS_ABILITATO(propertiesReader.isErroriGovWayStatusEnabled());
  2259.                 Costanti.setTRANSACTION_ERROR_INSTANCE_ID_ABILITATO(propertiesReader.isErroriGovWayInstanceEnabled());
  2260.                 Costanti.setTRANSACTION_FORCE_SPECIFIC_ERROR_DETAILS(propertiesReader.isErroriGovWayForceSpecificDetails());
  2261.                 Costanti.setTRANSACTION_ERROR_SOAP_FAULT_ADD_FAULT_DETAILS_WITH_PROBLEM_RFC7807(propertiesReader.isErroriGovWayFaultDetailsWithProblemRFC7807());
  2262.                 
  2263.                 Costanti.initPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE(propertiesReader.isProblemRFC7807_enrichTitleAsGovWayType());
  2264.                 Costanti.initPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE_CAMEL_CASE_DECODE(propertiesReader.isProblemRFC7807_enrichTitleAsGovWayType_camelCaseDecode());
  2265.                 Costanti.initPROBLEM_RFC7807_ENRICH_TITLE_AS_GOVWAY_TYPE_CUSTOM_CLAIM(propertiesReader.isProblemRFC7807_enrichTitleAsGovWayType_customClaim());
  2266.                 Costanti.initPROBLEM_RFC7807_GOVWAY_TRANSACTION_ID(propertiesReader.getProblemRFC7807_transactionId_claim());
  2267.                 Costanti.initPROBLEM_RFC7807_GOVWAY_CODE(propertiesReader.getProblemRFC7807_code_claim());
  2268.                 Costanti.initPROBLEM_RFC7807_GOVWAY_TYPE(propertiesReader.getProblemRFC7807_type_claim());
  2269.                                 
  2270.                 ProtocolFactoryManager.initialize(OpenSPCoop2Startup.log, configPdD, propertiesReader.getDefaultProtocolName());
  2271.                 // forzo update logger. (viene caricato dopo il log della console)
  2272.                 ProtocolFactoryManager.updateLogger(logCore);
  2273.                 protocolFactoryManager = ProtocolFactoryManager.getInstance();
  2274.                 // Update protocolLogger
  2275.                 boolean isInitializeLoggerProtocol = OpenSPCoop2Logger.initializeProtocolLogger(OpenSPCoop2Startup.log, true, propertiesReader.getRootDirectory(),loggerP); 
  2276.                 if(!isInitializeLoggerProtocol){
  2277.                     return;
  2278.                 }
  2279.                 // Initialize Protocols
  2280.                 protocolFactoryManager.initializeAllProtocols();
  2281.                 
  2282.                 // Inizializzazione schemi per altri message factory
  2283.                 if(messageFactory.size()>1) {
  2284.                     // La factory alla prima posizione, e' la factory di default già inizializzata
  2285.                     for (int i = 1; i < messageFactory.size(); i++) {
  2286.                         OpenSPCoop2MessageFactory factory = messageFactory.get(i);
  2287.                         Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolNames();
  2288.                         while (protocolli.hasMoreElements()) {
  2289.                             String protocollo = protocolli.nextElement();
  2290.                             if(ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo).createValidazioneConSchema(null).initialize(factory)==false) {
  2291.                                 throw new CoreException("Inizializzazione validatore con schemi per il protocollo '"+protocollo+"' e messagefactory '"+factory.getClass().getName()+"' fallita");
  2292.                             }
  2293.                         }
  2294.                     }
  2295.                 }
  2296.                 
  2297.                 // Inizializza RemoteStore
  2298.                 Enumeration<String> protocolli = ProtocolFactoryManager.getInstance().getProtocolNames();
  2299.                 while (protocolli.hasMoreElements()) {
  2300.                     String protocollo = protocolli.nextElement();
  2301.                     List<RemoteStoreConfig> lRSC = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocollo).createProtocolConfiguration().getRemoteStoreConfig();
  2302.                     if(lRSC!=null && !lRSC.isEmpty()) {
  2303.                         for (RemoteStoreConfig remoteStoreConfig : lRSC) {
  2304.                             RemoteStoreProviderDriver.initialize(logCore, remoteStoreConfig);
  2305.                             OpenSPCoop2Startup.logStartupInfo("Inizializzazione RemoteStoreProvider ["+remoteStoreConfig.getStoreLabel()+"] effettuata.");
  2306.                         }
  2307.                     }
  2308.                 }
  2309.                 
  2310.                 // Inizializzazione SignalHub
  2311.                 if(ProtocolFactoryManager.getInstance().existsProtocolFactory(org.openspcoop2.protocol.engine.constants.Costanti.MODIPA_PROTOCOL_NAME)) {
  2312.                     CostantiDB.setServiziDigestEnabled(ModIUtils.isSignalHubEnabled());
  2313.                 }
  2314.                 
  2315.                 OpenSPCoop2Startup.logStartupInfo("ProtocolFactory default: "+protocolFactoryManager.getDefaultProtocolFactory().getProtocol());
  2316.             } catch(Exception e) {
  2317.                 this.logError("Initialize ProtocolFactoryManager failed: "+e.getMessage());
  2318.                 logCore.error("Initialize ProtocolFactoryManager failed: "+e.getMessage(),e);
  2319.                 msgDiag.logStartupError("Riscontrato errore durante l'inizializzazione del ProtocolFactoryManager","initProtocolFactoryManager");
  2320.                 return;
  2321.             }
  2322.             
  2323.             
  2324.             
  2325.             
  2326.             
  2327.             
  2328.             /* ------------- Verifica Proprieta' di OpenSPCoop che richiedono l'inizializzazione del ProtocolFactoryManager --------------- */
  2329.             if(o!=null){
  2330.                 if(propertiesReader.validaConfigurazioneDopoInizializzazioneProtocolManager((java.lang.ClassLoader)o[0]) == false){
  2331.                     return;
  2332.                 }
  2333.             }else{
  2334.                 if(propertiesReader.validaConfigurazioneDopoInizializzazioneProtocolManager(null) == false){
  2335.                     return;
  2336.                 }
  2337.             }
  2338.             
  2339.             
  2340.             


  2343.             /* ------------- Inizializzo il sistema di Logging per gli appender personalizzati --------------- */
  2344.             boolean isInitializeAppender = false;
  2345.             isInitializeAppender = OpenSPCoop2Logger.initializeMsgDiagnosticiOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderMessaggiDiagnostici());
  2346.             if(!isInitializeAppender){
  2347.                 return;
  2348.             }
  2349.             isInitializeAppender = OpenSPCoop2Logger.initializeTracciamentoOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderTracciamento());
  2350.             if(!isInitializeAppender){
  2351.                 return;
  2352.             }
  2353.             isInitializeAppender = OpenSPCoop2Logger.initializeDumpOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderDump());
  2354.             if(!isInitializeAppender){
  2355.                 return;
  2356.             }





  2362.             






  2369.             /* -------------- Inizializzo QueueManager --------------- */
  2370.             if(OpenSPCoop2Startup.this.serverJ2EE){
  2371.                 if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeReceiver()) 
  2372.                         || CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeSender()) ){

  2374.                     // Connection Factory
  2375.                     try{
  2376.                         QueueManager.initialize(propertiesReader.getJNDIName_ConnectionFactory(),
  2377.                                 propertiesReader.getJNDIContext_ConnectionFactory());
  2378.                     }catch(Exception e){
  2379.                         msgDiag.logStartupError(e, "QueueManager.initConnectionFactory");
  2380.                         return;
  2381.                     }
  2382.                     OpenSPCoop2Startup.logStartupInfo("Inizializzazione connectionFactoryJMS ["+propertiesReader.getJNDIName_ConnectionFactory()+"] effettuata.");

  2384.                     // Code di Ricezione
  2385.                     if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeReceiver()) 
  2386.                     ){
  2387.                         try{
  2388.                             QueueManager.initializeQueueNodeReceiver(propertiesReader.getJNDIContext_CodeInterne());
  2389.                         }catch(Exception e){
  2390.                             msgDiag.logStartupError(e, "QueueManager.initQueueNodeReceiver");
  2391.                             return;
  2392.                         }
  2393.                         OpenSPCoop2Startup.logStartupInfo("Inizializzazione code JMS per la ricezione di messaggi nell'infrastruttura di OpenSPCoop, effettuata.");
  2394.                     }

  2396.                     // Code di Spedizione
  2397.                     //if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeSender()) 
  2398.                     //){
  2399.                     try{
  2400.                         QueueManager.initializeQueueNodeSender(propertiesReader.getJNDIContext_CodeInterne());
  2401.                     }catch(Exception e){
  2402.                         msgDiag.logStartupError(e, "QueueManager.initQueueNodeSender");
  2403.                         return;
  2404.                     }
  2405.                     OpenSPCoop2Startup.logStartupInfo("Inizializzazione code JMS per la spedizione di messaggi nell'infrastruttura di OpenSPCoop, effettuata.");
  2406.                 }
  2407.             }


  2410.             
  2411.             






  2418.             /* ----------- Inizializzazione Registro dei Servizi ---------------- */

  2420.             // Check configurazione registro dei Servizi
  2421.             if( configurazionePdDManager.getAccessoRegistroServizi() == null ){
  2422.                 msgDiag.logStartupError("Riscontrato errore durante la lettura dei valori associati al registro dei servizi di OpenSPCoop.", "Lettura configurazione PdD");
  2423.                 return;
  2424.             }

  2426.             // Controllo la consistenza dei registri di tipo DB
  2427.             AccessoRegistro accessoRegistro = configurazionePdDManager.getAccessoRegistroServizi();
  2428.             for(int i=0; i<accessoRegistro.sizeRegistroList(); i++){    
  2429.                 AccessoRegistroRegistro registro = accessoRegistro.getRegistro(i);
  2430.                 if(CostantiConfigurazione.REGISTRO_DB.equals(registro.getTipo().toString())){
  2431.                     // Il tipo del DB e' obbligatorio.
  2432.                     // Controllo che vi sia o
  2433.                     // - come prefisso del datasource: tipoDatabase@datasource
  2434.                     // - come tipo di database della porta di dominio.
  2435.                     if(registro.getLocation().indexOf("@")!=-1){
  2436.                         // estrazione tipo database
  2437.                         try{
  2438.                             String tipoDatabase = DBUtils.estraiTipoDatabaseFromLocation(registro.getLocation());
  2439.                             String location = registro.getLocation().substring(registro.getLocation().indexOf("@")+1);
  2440.                             accessoRegistro.getRegistro(i).setLocation(location);
  2441.                             accessoRegistro.getRegistro(i).setTipoDatabase(tipoDatabase);
  2442.                         }catch(Exception e){
  2443.                             msgDiag.logStartupError(e, "Inizializzazione registro dei servizi di OpenSPCoop ["+registro.getNome()+"]; analisi del tipo di database (tipoDatabase@datasource)");
  2444.                             return;
  2445.                         }
  2446.                     }else{
  2447.                         if(propertiesReader.getDatabaseType()==null){
  2448.                             msgDiag.logStartupError("Il Registro dei Servizi di tipo ["+CostantiConfigurazione.REGISTRO_DB+"] richiede la definizione del tipo di database indicato o come prefisso della location (tipoDB@datasource) o attraverso la proprieta' 'org.openspcoop.pdd.repository.tipoDatabase' della porta di dominio",
  2449.                                     "Inizializzazione registro dei servizi di OpenSPCoop ["+registro.getNome()+"]; analisi del tipo di database");
  2450.                             return;
  2451.                         }else{
  2452.                             accessoRegistro.getRegistro(i).setTipoDatabase(propertiesReader.getDatabaseType());
  2453.                         }
  2454.                     }
  2455.                 }
  2456.             }

  2458.             // inizializzo registri
  2459.             DriverBYOK driverBYOK = null;
  2460.             try{
  2461.                 driverBYOK = DriverBYOKUtilities.newInstanceDriverBYOKRuntimeNode(logCore, false, true);
  2462.             }catch(Exception e){
  2463.                 msgDiag.logStartupError(e,"Inizializzazione driver BYOK fallita");
  2464.                 return;
  2465.             }
  2466.             boolean isInitializeRegistro = 
  2467.                 RegistroServiziReader.initialize(accessoRegistro,
  2468.                         logCore,OpenSPCoop2Startup.log,propertiesReader.isControlloRisorseRegistriRaggiungibilitaTotale(),
  2469.                         propertiesReader.isReadObjectStatoBozza(),propertiesReader.getJNDIName_DataSource(),
  2470.                         propertiesReader.isDSOp2UtilsEnabled(), propertiesReader.isRisorseJMXAbilitate(),
  2471.                         propertiesReader.isConfigurazioneCache_RegistryPrefill(), propertiesReader.getCryptConfigAutenticazioneSoggetti(),
  2472.                         propertiesReader.getCacheTypeRegistry(), driverBYOK);
  2473.             if(!isInitializeRegistro){
  2474.                 msgDiag.logStartupError("Inizializzazione fallita","Accesso registro/i dei servizi");
  2475.                 return;
  2476.             }
  2477.             if(propertiesReader.isConfigurazioneCache_RegistryPrefill() && propertiesReader.isConfigurazioneCache_ConfigPrefill()){
  2478.                 try{
  2479.                     ConfigurazionePdDReader.prefillCacheConInformazioniRegistro(OpenSPCoop2Startup.log);
  2480.                 }catch(Exception e){
  2481.                     msgDiag.logStartupError(e,"Prefill ConfigurazionePdD e Registro Reader fallita");
  2482.                     return;
  2483.                 }
  2484.             }

  2486.             // Inizializza il reader del registro dei Servizi utilizzato nella configurazione
  2487.             /**try{
  2488.                 configurazionePdDReader.initializeRegistroServiziReader();
  2489.             }catch(Exception e){
  2490.                 msgDiag.logStartupError(e,"Inizializzazione Reader per il registro dei servizi utilizzato nella configurazione");
  2491.                 return;
  2492.             }*/


  2495.             
  2496.             
  2497.             
  2498.             
  2499.             
  2500.             
  2501.             
  2502.             /* ------------ PreLoading ------------- */
  2503.             
  2504.             if(propertiesReader.getConfigPreLoadingLocale()!=null) {
  2505.                 try{
  2506.                     
  2507.                     Object oConfig = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  2508.                     Object oRegistry = RegistroServiziReader.getDriverRegistroServizi().values().iterator().next();
  2509.                     if( (oConfig instanceof DriverConfigurazioneDB) && (oRegistry instanceof DriverRegistroServiziDB) ) {
  2510.                         PreLoadingConfig preLoading = new PreLoadingConfig(logCore, logCore, propertiesReader.getDefaultProtocolName(),
  2511.                                 propertiesReader.getIdentitaPortaDefault(propertiesReader.getDefaultProtocolName(), null));
  2512.                         
  2513.                         TimerLock timerLock = new TimerLock(TipoLock.STARTUP);
  2514.                         InfoStatistics semaphore_statistics = null;
  2515.                         Semaphore semaphore = null;
  2516.                         Logger logTimer = OpenSPCoop2Logger.getLoggerOpenSPCoopTimers();
  2517.                         if(propertiesReader.isTimerLockByDatabase()) {
  2518.                             semaphore_statistics = new InfoStatistics();

  2520.                             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(propertiesReader.getStartupLockMaxLife(), 
  2521.                                     propertiesReader.getStartupLockIdleTime());

  2523.                             TipiDatabase databaseType = TipiDatabase.toEnumConstant(propertiesReader.getDatabaseType());
  2524.                             try {
  2525.                                 semaphore = new Semaphore(semaphore_statistics, SemaphoreMapping.newInstance(timerLock.getIdLock()), 
  2526.                                         config, databaseType, logTimer);
  2527.                             }catch(Exception e) {
  2528.                                 throw new TimerException(e.getMessage(),e);
  2529.                             }
  2530.                         }
  2531.                         
  2532.                         OpenSPCoopStateful openspcoopstate = new OpenSPCoopStateful();
  2533.                         try {
  2534.                             openspcoopstate.initResource(propertiesReader.getIdentitaPortaDefaultWithoutProtocol(),ID_MODULO, null);
  2535.                             Connection connectionDB = ((StateMessage)openspcoopstate.getStatoRichiesta()).getConnectionDB();
  2536.                         
  2537.                             String causa = "Preloading Configuration";
  2538.                             try {
  2539.                                 GestoreMessaggi.acquireLock(
  2540.                                         semaphore, connectionDB, timerLock,
  2541.                                         msgDiag, causa, 
  2542.                                         propertiesReader.getStartupGetLockAttesaAttiva(), 
  2543.                                         propertiesReader.getStartupGetLockCheckInterval());
  2544.                                 
  2545.                                 preLoading.loadConfig(propertiesReader.getConfigPreLoadingLocale());
  2546.                                 
  2547.                             }finally{
  2548.                                 try{
  2549.                                     GestoreMessaggi.releaseLock(
  2550.                                             semaphore, connectionDB, timerLock,
  2551.                                             msgDiag, causa);
  2552.                                 }catch(Exception e){
  2553.                                     // ignore
  2554.                                 }
  2555.                             }
  2556.                             
  2557.                         }finally{
  2558.                             if(openspcoopstate!=null)
  2559.                                 openspcoopstate.releaseResource();
  2560.                         }
  2561.                             
  2562.                     }
  2563.                                         
  2564.                 }catch(Exception e){
  2565.                     this.logError("Riscontrato errore durante il preloading della configurazione di OpenSPCoop: "+e.getMessage(),e);
  2566.                     return;
  2567.                 }
  2568.             }







  2576.             // *** Repository plugins ***
  2577.             try{
  2578.                 if(propertiesReader.isConfigurazionePluginsEnabled()) {
  2579.                     CorePluginLoader.initialize(loader, OpenSPCoop2Logger.getLoggerOpenSPCoopPlugins(propertiesReader.isConfigurazionePluginsDebug()),
  2580.                             PddPluginLoader.class,
  2581.                             configurazionePdDManager.getRegistroPluginsReader(),
  2582.                             propertiesReader.getConfigurazionePluginsSeconds());
  2583.                 }
  2584.                 else {
  2585.                     CorePluginLoader.initialize(loader, OpenSPCoop2Logger.getLoggerOpenSPCoopPlugins(propertiesReader.isConfigurazionePluginsDebug()),
  2586.                             PddPluginLoader.class);
  2587.                 }
  2588.             }catch(Exception e){
  2589.                 msgDiag.logStartupError(e,"Inizializzazione plugins");
  2590.                 return;
  2591.             }
  2592.             
  2593.             
  2594.             
  2595.             




  2600.             /* ---------------- Validazione semantica -----------------------*/

  2602.             // Configurazione
  2603.             boolean validazioneSemanticaConfigurazione = false;
  2604.             if(CostantiConfigurazione.CONFIGURAZIONE_XML.equalsIgnoreCase(accessoConfigurazione.getTipo())){
  2605.                 validazioneSemanticaConfigurazione = propertiesReader.isValidazioneSemanticaConfigurazioneStartupXML();
  2606.             }else{
  2607.                 validazioneSemanticaConfigurazione = propertiesReader.isValidazioneSemanticaConfigurazioneStartup();
  2608.             }
  2609.             if(validazioneSemanticaConfigurazione){
  2610.                 try{
  2611.                     ConfigurazionePdDManager.getInstance().validazioneSemantica(classNameReader.getConnettore(), 
  2612.                             classNameReader.getMsgDiagnosticoOpenSPCoopAppender(),
  2613.                             classNameReader.getTracciamentoOpenSPCoopAppender(),
  2614.                             classNameReader.getDumpOpenSPCoopAppender(),
  2615.                             classNameReader.getAutenticazionePortaDelegata(), classNameReader.getAutenticazionePortaApplicativa(), 
  2616.                             classNameReader.getAutorizzazionePortaDelegata(), classNameReader.getAutorizzazionePortaApplicativa(),
  2617.                             classNameReader.getAutorizzazioneContenutoPortaDelegata(),classNameReader.getAutorizzazioneContenutoPortaApplicativa(),
  2618.                             classNameReader.getIntegrazionePortaDelegata(),
  2619.                             classNameReader.getIntegrazionePortaApplicativa(),
  2620.                             propertiesReader.isValidazioneSemanticaConfigurazioneStartupXML(),
  2621.                             propertiesReader.isValidazioneSemanticaConfigurazioneStartup(),
  2622.                             true, OpenSPCoop2Startup.log);
  2623.                     if(propertiesReader.isValidazioneSemanticaConfigurazioneStartupXML()){
  2624.                         ConfigurazionePdDManager.getInstance().setValidazioneSemanticaModificaConfigurazionePdDXML(classNameReader.getConnettore(), 
  2625.                                 classNameReader.getMsgDiagnosticoOpenSPCoopAppender(),
  2626.                                 classNameReader.getTracciamentoOpenSPCoopAppender(),
  2627.                                 classNameReader.getDumpOpenSPCoopAppender(),
  2628.                                 classNameReader.getAutenticazionePortaDelegata(), classNameReader.getAutenticazionePortaApplicativa(), 
  2629.                                 classNameReader.getAutorizzazionePortaDelegata(), classNameReader.getAutorizzazionePortaApplicativa(),
  2630.                                 classNameReader.getAutorizzazioneContenutoPortaDelegata(),classNameReader.getAutorizzazioneContenutoPortaApplicativa(),
  2631.                                 classNameReader.getIntegrazionePortaDelegata(),
  2632.                                 classNameReader.getIntegrazionePortaApplicativa());
  2633.                     }
  2634.                 }catch(Exception e){
  2635.                     msgDiag.logStartupError(e,"Validazione semantica della configurazione");
  2636.                     return;
  2637.                 }
  2638.             }

  2640.             // Registro dei Servizi
  2641.             try{
  2642.                 RegistroServiziManager.getInstance().validazioneSemantica(true, propertiesReader.isValidazioneSemanticaRegistroServiziCheckURI(), 
  2643.                         protocolFactoryManager.getOrganizationTypesAsArray(),
  2644.                         protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.SOAP),
  2645.                         protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.REST),
  2646.                         classNameReader.getConnettore(),
  2647.                         propertiesReader.isValidazioneSemanticaRegistroServiziStartupXML(),
  2648.                         propertiesReader.isValidazioneSemanticaRegistroServiziStartup(),OpenSPCoop2Startup.log);        
  2649.                 if(propertiesReader.isValidazioneSemanticaRegistroServiziStartupXML()){
  2650.                     RegistroServiziManager.getInstance().setValidazioneSemanticaModificaRegistroServiziXML(propertiesReader.isValidazioneSemanticaRegistroServiziCheckURI(), 
  2651.                             protocolFactoryManager.getOrganizationTypesAsArray(),
  2652.                             protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.SOAP),
  2653.                             protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.REST),
  2654.                             classNameReader.getConnettore());
  2655.                 }
  2656.             }catch(Exception e){
  2657.                 msgDiag.logStartupError(e,"Validazione semantica del registro dei servizi");
  2658.                 return;
  2659.             }

  2661.             // Libreria di validazione xsd
  2662.             try {
  2663.                 XSDSchemaCollection.setSerializeXSDSchemiBuildSchemaSuccessDefault(propertiesReader.isValidazioneContenutiApplicativiXsdBuildSchemaSuccessSerializeXSDCollection());
  2664.                 XSDSchemaCollection.setSerializeXSDSchemiBuildSchemaErrorDefault(propertiesReader.isValidazioneContenutiApplicativiXsdBuildSchemaErrorSerializeXSDCollection());
  2665.                 XSDSchemaCollection.setSerializeXSDSchemiBuildSchemaDefaultDir(propertiesReader.getValidazioneContenutiApplicativiXsdBuildSchemaSerializeXSDCollectionDir());
  2666.                                 
  2667.                 XSDSchemaCollection s = new XSDSchemaCollection();
  2668.                 OpenSPCoop2Startup.logStartupInfo("XSDSchemaCollection buildSchemaSuccess:"+s.isSerializeXSDSchemiBuildSchemaSuccess());
  2669.                 OpenSPCoop2Startup.logStartupInfo("XSDSchemaCollection buildSchemaError:"+s.isSerializeXSDSchemiBuildSchemaError());
  2670.                 OpenSPCoop2Startup.logStartupInfo("XSDSchemaCollection buildSchemaDir:"+s.getSerializeXSDSchemiBuildSchemaDir());
  2671.             }catch(Exception e){
  2672.                 msgDiag.logStartupError(e,"Configurazione libreria di validazione xsd");
  2673.                 return;
  2674.             }
  2675.             
  2676.             // Libreria di validazione wsdl
  2677.             try {
  2678.                 boolean normalizeNamespaceXSITypeDefault = propertiesReader.isValidazioneContenutiApplicativiRpcAddNamespaceXSITypeIfNotExists()
  2679.                         ||
  2680.                         propertiesReader.isValidazioneContenutiApplicativiDocumentAddNamespaceXSITypeIfNotExists()
  2681.                         ||
  2682.                         propertiesReader.isValidazioneContenutiApplicativiXsdAddNamespaceXSITypeIfNotExists();
  2683.                 AbstractBaseOpenSPCoop2Message.setNormalizeNamespaceXSITypeDefault(normalizeNamespaceXSITypeDefault);
  2684.                 OpenSPCoop2Message msg = OpenSPCoop2MessageFactory.getDefaultMessageFactory().createEmptyMessage(MessageType.SOAP_11, MessageRole.REQUEST);
  2685.                 if(msg instanceof AbstractBaseOpenSPCoop2Message) {
  2686.                     AbstractBaseOpenSPCoop2Message a = (AbstractBaseOpenSPCoop2Message) msg;
  2687.                     OpenSPCoop2Startup.logStartupInfo("WSDLValidator addNamespaceXSITypeIfNotExists:"+a.isNormalizeNamespaceXSIType());
  2688.                 }
  2689.             }catch(Exception e){
  2690.                 msgDiag.logStartupError(e,"Configurazione libreria di validazione wsdl");
  2691.                 return;
  2692.             }
  2693.             
  2694.             // Libreria di validazione openapi4j
  2695.             try {
  2696.                 org.openapi4j.schema.validator.v3.ValidationOptions.VALIDATE_BASE64_VALUES=propertiesReader.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateBase64Values();
  2697.                 org.openapi4j.parser.validation.v3.OpenApi3Validator.VALIDATE_URI_REFERENCE_AS_URL = propertiesReader.isValidazioneContenutiApplicativiOpenApiOpenapi4jValidateUriReferenceAsUrl();
  2698.                 org.openapi4j.schema.validator.v3.FormatValidator.setDateTimeAllowLowerCaseTZ(propertiesReader.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ());
  2699.                 org.openapi4j.schema.validator.v3.FormatValidator.setDateTimeAllowSpaceSeparator(propertiesReader.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator());
  2700.             }catch(Exception e){
  2701.                 msgDiag.logStartupError(e,"Configurazione libreria di validazione openapi4j");
  2702.                 return;
  2703.             }
  2704.             
  2705.             // Libreria di validazione generica delle dae
  2706.             try {
  2707.                 DateUtils.setDateTimeAllowLowerCaseTZ(propertiesReader.isValidazioneContenutiApplicativiOpenApiDateTimeAllowLowerCaseTZ());
  2708.                 DateUtils.setDateTimeAllowSpaceSeparator(propertiesReader.isValidazioneContenutiApplicativiOpenApiDateTimeAllowSpaceSeparator());
  2709.             }catch(Exception e){
  2710.                 msgDiag.logStartupError(e,"Configurazione libreria di validazione DateUtils");
  2711.                 return;
  2712.             }



  2716.         
  2717.         
  2718.         
  2719.         
  2720.             /* ----------- Inizializzo GestoreMessaggi Cache ------------ */
  2721.             try{
  2722.                 GestoreMessaggi.initialize();
  2723.             }catch(Exception e){
  2724.                 msgDiag.logStartupError(e,"Cache GestoreMessaggi");
  2725.                 return;
  2726.             }
  2727.         
  2728.         
  2729.         
  2730.         
  2731.             
  2732.             /* ----------- Inizializzazione MessageSecurity ------------ */
  2733.             try{
  2734.                 String wssPropertiesFileExternalPWCallback = propertiesReader.getExternalPWCallbackPropertyFile();
  2735.                 if(wssPropertiesFileExternalPWCallback!=null){
  2736.                     ExternalPWCallback.initialize(wssPropertiesFileExternalPWCallback);
  2737.                 }
  2738.                 
  2739.                 // DEVE essere effettuata all'inizio, vedi sopra.
  2740.                 //org.apache.wss4j.dom.engine.WSSConfig.init();
  2741.                 
  2742.             }catch(Exception e){
  2743.                 msgDiag.logStartupError(e,"Inizializzazione MessageSecurity");
  2744.                 return;
  2745.             }

  2747.             
  2748.             
  2749.             
  2750.             
  2751.             
  2752.         
  2753.         
  2754.         
  2755.         
  2756.             /* ----------- Inizializzazione Servizi ------------ */
  2757.             try{
  2758.                 StatoServiziPdD.initialize();
  2759.             }catch(Exception e){
  2760.                 msgDiag.logStartupError(e,"Inizializzazione stato servizi");
  2761.                 return;
  2762.             }
  2763.             try{
  2764.                 RicezioneContenutiApplicativi.initializeService(configurazionePdDManager, classNameReader, propertiesReader, logCore);
  2765.             }catch(Exception e){
  2766.                 msgDiag.logStartupError(e,"Inizializzazione servizio RicezioneContenutiApplicativi");
  2767.                 return;
  2768.             }
  2769.             try{
  2770.                 RicezioneBuste.initializeService(configurazionePdDManager,classNameReader, propertiesReader, logCore);
  2771.             }catch(Exception e){
  2772.                 msgDiag.logStartupError(e,"Inizializzazione servizio RicezioneBuste");
  2773.                 return;
  2774.             }
  2775.             try{
  2776.                 InoltroBuste.initializeService(classNameReader, propertiesReader);
  2777.             }catch(Exception e){
  2778.                 msgDiag.logStartupError(e,"Inizializzazione servizio InoltroBuste");
  2779.                 return;
  2780.             }
  2781.             try{
  2782.                 ConsegnaContenutiApplicativi.initializeService(classNameReader, propertiesReader);
  2783.             }catch(Exception e){
  2784.                 msgDiag.logStartupError(e,"Inizializzazione servizio ConsegnaContenutiApplicativi");
  2785.                 return;
  2786.             }
  2787.             try{
  2788.                 IDAccordoFactory.getInstance();
  2789.                 IDAccordoCooperazioneFactory.getInstance();
  2790.             }catch(Exception e){
  2791.                 msgDiag.logStartupError(e,"Inizializzazione factory ID");
  2792.                 return;
  2793.             }
  2794.             
  2795.             
  2796.             
  2797.             
  2798.             /* ----------- Inizializzazione Mailcap Activation per Gestione Attachments ------------ */
  2799.             try{
  2800.                 MailcapActivationReader.initDataContentHandler(OpenSPCoop2Startup.log,propertiesReader.isTunnelSOAP_loadMailcap());
  2801.             }catch(Exception e){
  2802.                 msgDiag.logStartupError(e,"Inizializzazione DataContentHandler (MET-INF/mailcap)");
  2803.                 return;
  2804.             }
  2805.         
  2806.         
  2807.             
  2808.             
  2809.             
  2810.             
  2811.             
  2812.             
  2813.             
  2814.             /* ----------- Directory ------------ */
  2815.             FileSystemMkdirConfig configMkdir = null;
  2816.             try{
  2817.                 
  2818.                 configMkdir = new FileSystemMkdirConfig();
  2819.                 configMkdir.setCheckCanWrite(true);
  2820.                 configMkdir.setCheckCanRead(true);
  2821.                 configMkdir.setCheckCanExecute(false);
  2822.                 configMkdir.setCrateParentIfNotExists(true);
  2823.                 
  2824.                 // logDir (sarebbe meglio se fosse creata dall'utente)
  2825.                 List<File> listFiles = OpenSPCoop2Logger.getLogDirs();
  2826.                 if(listFiles!=null && !listFiles.isEmpty()) {
  2827.                     for (File file : listFiles) {
  2828.                         if(!file.exists()){
  2829.                             // Il Log può non funzionare
  2830.                             String msg = "WARNING: Log dir ["+file.getAbsolutePath()+"] non trovata. La directory verrà creata ma è possibile che serva un ulteriore riavvio dell'Application Server";
  2831.                             log.warn(msg);
  2832.                             System.out.println(msg);
  2833.                         }
  2834.                         FileSystemUtilities.mkdir(file, configMkdir);
  2835.                     }
  2836.                 }

  2838.                 // messageRepository
  2839.                 if(propertiesReader.isRepositoryOnFS()) {
  2840.                     File dir = new File(propertiesReader.getRepositoryDirectory());
  2841.                     FileSystemUtilities.mkdir(dir, configMkdir);
  2842.                 }
  2843.                 
  2844.                 // https
  2845.                 if(propertiesReader.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_consegnaContenutiApplicativi()) {
  2846.                     File dir = propertiesReader.getConnettoreHttp_urlHttps_repository_consegnaContenutiApplicativi();
  2847.                     configMkdir.setCheckCanWrite(false);
  2848.                     FileSystemUtilities.mkdir(dir, configMkdir);
  2849.                     configMkdir.setCheckCanWrite(true);
  2850.                 }
  2851.                 if(propertiesReader.isConnettoreHttp_urlHttps_overrideDefaultConfiguration_inoltroBuste()) {
  2852.                     File dir = propertiesReader.getConnettoreHttp_urlHttps_repository_inoltroBuste();
  2853.                     configMkdir.setCheckCanWrite(false);
  2854.                     FileSystemUtilities.mkdir(dir, configMkdir);
  2855.                     configMkdir.setCheckCanWrite(true);
  2856.                 }
  2857.                 
  2858.                 // recovery
  2859.                 File dirRecovery = propertiesReader.getFileSystemRecoveryRepository();
  2860.                 FileSystemUtilities.mkdir(dirRecovery, configMkdir);
  2861.                 FileSystemSerializer fs = FileSystemSerializer.getInstance();
  2862.                 FileSystemUtilities.mkdir(fs.getDirTransazioni().getAbsolutePath(), configMkdir);
  2863.                 FileSystemUtilities.mkdir(fs.getDirTransazioneApplicativoServer().getAbsolutePath(), configMkdir);
  2864.                 FileSystemUtilities.mkdir(fs.getDirTransazioneApplicativoServerConsegnaTerminata().getAbsolutePath(), configMkdir);
  2865.                 FileSystemUtilities.mkdir(fs.getDirDiagnostici().getAbsolutePath(), configMkdir);
  2866.                 FileSystemUtilities.mkdir(fs.getDirTracce().getAbsolutePath(), configMkdir);
  2867.                 FileSystemUtilities.mkdir(fs.getDirDump().getAbsolutePath(), configMkdir);
  2868.                 FileSystemUtilities.mkdir(fs.getDirEventi().getAbsolutePath(), configMkdir);
  2869.                 
  2870.                 // dumpBinario
  2871.                 File dirBinario = propertiesReader.getDumpBinarioRepository();
  2872.                 FileSystemUtilities.mkdir(dirBinario, configMkdir);
  2873.                                 
  2874.                 // dumpNotRealTime
  2875.                 if(propertiesReader.isDumpNonRealtimeFileSystemMode()) {
  2876.                     File dir = propertiesReader.getDumpNonRealtimeRepository();
  2877.                     FileSystemUtilities.mkdir(dir, configMkdir);
  2878.                 }
  2879.                 
  2880.                 // attachments
  2881.                 AttachmentsProcessingMode attachProcessingMode = propertiesReader.getAttachmentsProcessingMode();
  2882.                 if(attachProcessingMode!=null && attachProcessingMode.getFileRepository()!=null){
  2883.                     File dir = attachProcessingMode.getFileRepository();
  2884.                     FileSystemUtilities.mkdir(dir, configMkdir);
  2885.                 }
  2886.                 
  2887.                 // controlloTraffico
  2888.                 if(propertiesReader.isControlloTrafficoEnabled()){
  2889.                     File dirCT = propertiesReader.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  2890.                     if(dirCT!=null){
  2891.                         FileSystemUtilities.mkdir(dirCT, configMkdir);
  2892.                     }
  2893.                 }
  2894.                 
  2895.             }catch(Exception e){
  2896.                 msgDiag.logStartupError(e,"Inizializzazione Directory");
  2897.                 return;
  2898.             }
  2899.             
  2900.             
  2901.             
  2902.             
  2903.             
  2904.             
  2905.             
  2906.             
  2907.             /* ----------- Gestori utilizzati dal Controllo Traffico ------------ */
  2908.             if(propertiesReader.isControlloTrafficoEnabled()){
  2909.                         
  2910.                 try{
  2911.                     propertiesReader.initConfigurazioneControlloTraffico(loader, ProtocolFactoryManager.getInstance().getProtocolNamesAsList());
  2912.                 }catch(Exception e){
  2913.                     msgDiag.logStartupError(e,"Inizializzazione Configurazione ControlloTraffico");
  2914.                     return;
  2915.                 }
  2916.                 
  2917.                 Logger logControlloTraffico = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(propertiesReader.isControlloTrafficoDebug());
  2918.                 
  2919.                 // Cache ControlloTraffico DatiStatistici
  2920.                 try{
  2921.                     ConfigurazioneGenerale configurazioneControlloTraffico = configurazionePdDManager.getConfigurazioneControlloTraffico(null);
  2922.                     if(configurazioneControlloTraffico.getCache()!=null && configurazioneControlloTraffico.getCache().isCache()){
  2923.                         GestoreCacheControlloTraffico.initializeCache(propertiesReader.getCacheTypeTrafficControl(),configurazioneControlloTraffico.getCache().getSize(),
  2924.                                 CacheAlgorithm.LRU.equals(configurazioneControlloTraffico.getCache().getAlgorithm()),
  2925.                                 configurazioneControlloTraffico.getCache().getIdleTime(), 
  2926.                                 configurazioneControlloTraffico.getCache().getLifeTime(), 
  2927.                                 logCore);
  2928.                         logControlloTraffico.info("Cache ControlloTraffico inizializzata");
  2929.                     }
  2930.                 }catch(Exception e){
  2931.                     msgDiag.logStartupError(e,"Inizializzazione Cache ControlloTraffico");
  2932.                     return;
  2933.                 }
  2934.                     
  2935.                 // Gestore dei Dati Statistici
  2936.                 org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico confControlloTraffico = null;
  2937.                 try{
  2938.                     confControlloTraffico = propertiesReader.getConfigurazioneControlloTraffico();

  2940.                     DatiStatisticiDAOManager.initialize(confControlloTraffico);
  2941.                 }catch(Exception e){
  2942.                     msgDiag.logStartupError(e,"Inizializzazione Gestori Dati Statistici del ControlloTraffico");
  2943.                     return;
  2944.                 }
  2945.                 
  2946.                 // Gestore Controllo Traffico
  2947.                 try{
  2948.                     GestoreControlloTraffico.initialize(confControlloTraffico.isErroreGenerico());
  2949.                     GestoreCacheControlloTraffico.initialize(confControlloTraffico);
  2950.                 }catch(Exception e){
  2951.                     msgDiag.logStartupError(e,"Inizializzazione Gestori del ControlloTraffico");
  2952.                     return;
  2953.                 }
  2954.                 
  2955.                 // HazelcastManager
  2956.                 if(propertiesReader.isHazelcastEngineEnabled()) {
  2957.                     setSystemProperties(org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.SECURITY_RECOMMENDATIONS, 
  2958.                             propertiesReader.isHazelcastSecurityRecommendationsEnabled() ? 
  2959.                                     org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.SECURITY_RECOMMENDATIONS_ENABLED :
  2960.                                     org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.SECURITY_RECOMMENDATIONS_DISABLED);
  2961.                     
  2962.                     boolean diag = propertiesReader.isHazelcastDiagnosticsEnabled();
  2963.                     setSystemProperties(org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS, 
  2964.                             diag ? 
  2965.                                     org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS_ENABLED :
  2966.                                     org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS_DISABLED);
  2967.                     if(diag) {
  2968.                         try{
  2969.                             File hazelcastDiagnosticDir = propertiesReader.getHazelcastDiagnosticsDirectory();
  2970.                             FileSystemUtilities.mkdir(hazelcastDiagnosticDir, configMkdir);
  2971.                             setSystemProperties(org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS_DIRECTORY, hazelcastDiagnosticDir.getAbsolutePath());
  2972.                             setSystemProperties(org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS_DIRECTORY_MAX_ROLLED_FILE_COUNT, propertiesReader.getHazelcastDiagnosticsMaxRolledFileCount()+"");
  2973.                             setSystemProperties(org.openspcoop2.pdd.core.controllo_traffico.policy.driver.hazelcast.Costanti.DIAGNOSTICS_DIRECTORY_MAX_FILE_SIZE_MB, propertiesReader.getHazelcastDiagnosticsMaxFileSizeMb()+"");
  2974.                         }catch(Exception e){
  2975.                             msgDiag.logStartupError(e,"Inizializzazione Hazelcast diagnostic configuration");
  2976.                             return;
  2977.                         }
  2978.                     }
  2979.                     
  2980.                     try{
  2981.                         Map<PolicyGroupByActiveThreadsType,String> config = new HashMap<>();
  2982.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_MAP, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastMapConfigPath());
  2983.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_NEAR_CACHE, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheConfigPath());
  2984.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_LOCAL_CACHE, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastLocalCacheConfigPath());
  2985.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_NEAR_CACHE_UNSAFE_SYNC_MAP, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeSyncMapConfigPath());
  2986.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_NEAR_CACHE_UNSAFE_ASYNC_MAP, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastNearCacheUnsafeAsyncMapConfigPath());
  2987.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_REPLICATED_MAP, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastReplicatedMapConfigPath());
  2988.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_ATOMIC_LONG, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongConfigPath());
  2989.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_ATOMIC_LONG_ASYNC, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastAtomicLongAsyncConfigPath());
  2990.                         config.put(PolicyGroupByActiveThreadsType.HAZELCAST_PNCOUNTER, propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastPNCounterConfigPath());
  2991.                         HazelcastManager.initialize(log, logControlloTraffico, config, 
  2992.                                 propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastGroupId(),
  2993.                                 propertiesReader.getControlloTrafficoGestorePolicyInMemoryHazelCastSharedConfig());
  2994.                     }catch(Exception e){
  2995.                         msgDiag.logStartupError(e,"Inizializzazione HazelcastManager");
  2996.                         return;
  2997.                     }
  2998.                 }
  2999.                 
  3000.                 // RedisManager
  3001.                 if(propertiesReader.isRedisEngineEnabled()) {
  3002.                     try{
  3003.                         RedissonManager.initialize(log, logControlloTraffico, propertiesReader.getControlloTrafficoGestorePolicyInMemoryRedisConnectionUrl());
  3004.                     }catch(Exception e){
  3005.                         msgDiag.logStartupError(e,"Inizializzazione RedisManager");
  3006.                         return;
  3007.                     }
  3008.                 }
  3009.                 
  3010.                 // Gestore RateLimiting
  3011.                 List<PolicyGroupByActiveThreadsType> listGestorePolicyRT = null;
  3012.                 try{
  3013.                     List<PolicyGroupByActiveThreadsType> listConfig = configurazionePdDManager.getTipiGestoreRateLimiting();
  3014.                     List<PolicyGroupByActiveThreadsType> listStartup = null;
  3015.                     if(listConfig!=null && !listConfig.isEmpty()) {
  3016.                         listStartup = new ArrayList<PolicyGroupByActiveThreadsType>();
  3017.                         for (PolicyGroupByActiveThreadsType type : listConfig) {
  3018.                             if(propertiesReader.isControlloTrafficoGestorePolicyInMemoryTypeLazyInitialization(type)) {
  3019.                                 log.debug("Gestore Policy di RateLimiting '"+type+"' trovato nella configurazione non inizializzato (lazy); verrà attivato alla prima richiesta."); 
  3020.                             }
  3021.                             else {
  3022.                                 listStartup.add(type);
  3023.                             }
  3024.                         }
  3025.                     }
  3026.                     GestorePolicyAttive.initialize(log, logControlloTraffico, propertiesReader.getControlloTrafficoGestorePolicyTipo(),
  3027.                             propertiesReader.getControlloTrafficoGestorePolicyWSUrl(),
  3028.                             listStartup);
  3029.                     listGestorePolicyRT = GestorePolicyAttive.getTipiGestoriAttivi();
  3030.                 }catch(Exception e){
  3031.                     msgDiag.logStartupError(e,"Inizializzazione Gestori Policy di Rate Limiting");
  3032.                     return;
  3033.                 }
  3034.                 if(listGestorePolicyRT!=null && !listGestorePolicyRT.isEmpty()) {
  3035.                     for (PolicyGroupByActiveThreadsType type : listGestorePolicyRT) {
  3036.                         
  3037.                         if(type.isRedis() && !RedissonManager.isRedissonClientInitialized()) {
  3038.                             // se arrivo qua, significa che nella proprietà di openspcoop ho accettato questa condizione.
  3039.                             // chiamarente se Redis server non e' disponibile, non posso neanche inizializzarlo
  3040.                             continue;
  3041.                         }
  3042.                         
  3043.                         File fDati = null;
  3044.                         try{
  3045.                             File fRepository = propertiesReader.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  3046.                             if(fRepository!=null){
  3047.                                 if(!fRepository.exists()){
  3048.                                     throw new CoreException("Directory ["+fRepository.getAbsolutePath()+"] not exists");
  3049.                                 }
  3050.                                 if(!fRepository.isDirectory()){
  3051.                                     throw new CoreException("File ["+fRepository.getAbsolutePath()+"] is not directory");
  3052.                                 }
  3053.                                 if(!fRepository.canRead()){
  3054.                                     throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot read");
  3055.                                 }
  3056.                                 if(!fRepository.canWrite()){
  3057.                                     throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot write");
  3058.                                 }
  3059.                                 fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoImage(type));
  3060.                                 if(fDati.exists() && fDati.canRead() && fDati.length()>0){
  3061.                                     FileInputStream fin = new FileInputStream(fDati);
  3062.                                     GestorePolicyAttive.getInstance(type).initialize(fin,confControlloTraffico);
  3063.                                     if(!fDati.delete()) {
  3064.                                         // ignore
  3065.                                     }
  3066.                                 }
  3067.                             }
  3068.                         }catch(Throwable e){
  3069.                             String img = null;
  3070.                             if(fDati!=null){
  3071.                                 img = fDati.getAbsolutePath();
  3072.                             }
  3073.                             logControlloTraffico.error("Inizializzazione dell'immagine ["+img+"] per il Gestore delle Policy di RateLimiting (tipo:"+type+") non riuscita: "+e.getMessage(),e);
  3074.                             logCore.error("Inizializzazione dell'immagine ["+img+"] per il Gestore delle Policy di RateLimiting (tipo:"+type+" non riuscita: "+e.getMessage(),e);
  3075.                             msgDiag.logStartupError(e,"Inizializzazione Immagine delle Policy di RateLimiting (tipo:"+type+")");
  3076.                             return;
  3077.                         }
  3078.                     }
  3079.                     
  3080.                     // ripulisco vecchi contatori rimasti in memoria
  3081.                     for (PolicyGroupByActiveThreadsType type : listGestorePolicyRT) {
  3082.                         try{
  3083.                             GestorePolicyAttive.getInstance(type).cleanOldActiveThreadsPolicy();
  3084.                         }catch(Throwable e){
  3085.                             logControlloTraffico.error("Pulizia dei dati presenti nella memoria del gestore delle Policy di RateLimiting (tipo:"+type+") non riuscita: "+e.getMessage(),e);
  3086.                             logCore.error("Pulizia dei dati presenti nella memoria del gestore delle Policy di RateLimiting (tipo:"+type+") non riuscita: "+e.getMessage(),e);
  3087.                             msgDiag.logStartupError(e,"Pulizia dei dati presenti nella memoria del gestore delle Policy di RateLimiting (tipo:"+type+")");
  3088.                         }
  3089.                     }
  3090.                     
  3091.                 }
  3092.                 
  3093.                 boolean force = true;
  3094.                 OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(force).info("Motore di gestione del Controllo del Traffico avviato correttamente");
  3095.             }
  3096.             
  3097.             
  3098.             
  3099.             
  3100.             
  3101.             
  3102.             

  3104.         
  3105.             /* ----------- Inizializzazione Risorse JMX ------------ */
  3106.             if( OpenSPCoop2Startup.this.gestoreRisorseJMX!=null ){
  3107.                 // MBean ConfigurazionePdD
  3108.                 try{
  3109.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanConfigurazionePdD();
  3110.                 }catch(Exception e){
  3111.                     msgDiag.logStartupError(e,"RisorsaJMX - configurazione");
  3112.                 }
  3113.                 // MBean Registro dei Servizi
  3114.                 try{
  3115.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanAccessoRegistroServizi();
  3116.                 }catch(Exception e){
  3117.                     msgDiag.logStartupError(e,"RisorsaJMX - accesso al Registro dei Servizi");
  3118.                 }
  3119.                 // MBean Monitoraggio Risorse
  3120.                 try{
  3121.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanMonitoraggioRisorse();
  3122.                 }catch(Exception e){
  3123.                     msgDiag.logStartupError(e,"RisorsaJMX - monitoraggio delle Risorse");
  3124.                 }
  3125.                 // MBean Autorizzazione
  3126.                 try{
  3127.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanAutorizzazione();
  3128.                 }catch(Exception e){
  3129.                     msgDiag.logStartupError(e,"RisorsaJMX - dati di autorizzazione");
  3130.                 }
  3131.                 // MBean Autenticazione
  3132.                 try{
  3133.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanAutenticazione();
  3134.                 }catch(Exception e){
  3135.                     msgDiag.logStartupError(e,"RisorsaJMX - dati di autenticazione");
  3136.                 }
  3137.                 // MBean GestioneToken
  3138.                 try{
  3139.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanGestioneToken();
  3140.                 }catch(Exception e){
  3141.                     msgDiag.logStartupError(e,"RisorsaJMX - dati di gestione dei token");
  3142.                 }
  3143.                 // MBean AttributeAuthority
  3144.                 try{
  3145.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanAttributeAuthority();
  3146.                 }catch(Exception e){
  3147.                     msgDiag.logStartupError(e,"RisorsaJMX - dati raccolti tramite attribute authority");
  3148.                 }
  3149.                 // MBean GestioneResponseCaching
  3150.                 try{
  3151.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanResponseCaching();
  3152.                 }catch(Exception e){
  3153.                     msgDiag.logStartupError(e,"RisorsaJMX - risposte salvate in cache");
  3154.                 }
  3155.                 // MBean GestioneKeystoreCaching
  3156.                 try{
  3157.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanKeystoreCaching();
  3158.                 }catch(Exception e){
  3159.                     msgDiag.logStartupError(e,"RisorsaJMX - keystore salvate in cache");
  3160.                 }
  3161.                 // MBean GestioneConsegnaApplicativi
  3162.                 try{
  3163.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanConsegnaApplicativi();
  3164.                 }catch(Exception e){
  3165.                     msgDiag.logStartupError(e,"RisorsaJMX - gestione consegna applicativi");
  3166.                 }
  3167.                 // MBean RepositoryMessaggi
  3168.                 try{
  3169.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanRepositoryMessaggi();
  3170.                 }catch(Exception e){
  3171.                     msgDiag.logStartupError(e,"RisorsaJMX - repository dei messaggi");
  3172.                 }
  3173.                 // MBean StatoServiziPdD
  3174.                 try{
  3175.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanStatoServiziPdD();
  3176.                 }catch(Exception e){
  3177.                     msgDiag.logStartupError(e,"RisorsaJMX - stato servizi");
  3178.                 }
  3179.                 // MBean StatistichePdD
  3180.                 try{
  3181.                     if(propertiesReader.isStatisticheViaJmx()) {
  3182.                         OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanStatistichePdD();
  3183.                     }
  3184.                 }catch(Exception e){
  3185.                     msgDiag.logStartupError(e,"RisorsaJMX - statistiche");
  3186.                 }
  3187.                 // MBean SystemPropertiesPdD
  3188.                 try{
  3189.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanSystemPropertiesPdD();
  3190.                 }catch(Exception e){
  3191.                     msgDiag.logStartupError(e,"RisorsaJMX - proprietà di sistema");
  3192.                 }
  3193.                 // MBean ConfigurazioneSistema
  3194.                 try{
  3195.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanConfigurazioneSistema();
  3196.                 }catch(Exception e){
  3197.                     msgDiag.logStartupError(e,"RisorsaJMX - configurazione di sistema");
  3198.                 }
  3199.                 if(propertiesReader.isControlloTrafficoEnabled()){
  3200.                     // MBean ControlloTraffico
  3201.                     try{
  3202.                         OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanControlloTraffico();
  3203.                     }catch(Exception e){
  3204.                         msgDiag.logStartupError(e,"RisorsaJMX - Controllo del Traffico");
  3205.                     }
  3206.                 }
  3207.                 // MBean GestoreRichieste
  3208.                 try{
  3209.                     OpenSPCoop2Startup.this.gestoreRisorseJMX.registerMBeanGestioneRichieste();
  3210.                 }catch(Exception e){
  3211.                     msgDiag.logStartupError(e,"RisorsaJMX - gestione richieste");
  3212.                 }
  3213.             }


  3216.             
  3217.             
  3218.             
  3219.             
  3220.             /* ----------- Log Configurazione di Sistema ------------ */
  3221.             
  3222.             InformazioniStatoPorta informazioniStatoPorta = new InformazioniStatoPorta();
  3223.             List<InformazioniStatoPortaCache> informazioniStatoPortaCache = new ArrayList<>();
  3224.             
  3225.             AccessoRegistroServizi infoRegistroServizi = new AccessoRegistroServizi();
  3226.             InformazioniStatoPortaCache informazioniStatoPortaCacheRegistro = new InformazioniStatoPortaCache(CostantiPdD.JMX_REGISTRO_SERVIZI, infoRegistroServizi.isCacheAbilitata());
  3227.             if(infoRegistroServizi.isCacheAbilitata()){
  3228.                 informazioniStatoPortaCacheRegistro.setStatoCache(infoRegistroServizi.printStatCache());
  3229.             }
  3230.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheRegistro);
  3231.             
  3232.             org.openspcoop2.pdd.core.jmx.ConfigurazionePdD infoConfigurazione = new org.openspcoop2.pdd.core.jmx.ConfigurazionePdD();
  3233.             InformazioniStatoPortaCache informazioniStatoPortaCacheConfig = new InformazioniStatoPortaCache(CostantiPdD.JMX_CONFIGURAZIONE_PDD, infoConfigurazione.isCacheAbilitata());
  3234.             if(infoConfigurazione.isCacheAbilitata()){
  3235.                 informazioniStatoPortaCacheConfig.setStatoCache(infoConfigurazione.printStatCache());
  3236.             }
  3237.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheConfig);
  3238.             
  3239.             org.openspcoop2.pdd.core.jmx.EngineAutorizzazione infoAutorizzazioneDati = new org.openspcoop2.pdd.core.jmx.EngineAutorizzazione();
  3240.             InformazioniStatoPortaCache informazioniStatoPortaCacheAutorizzazioneDati = new InformazioniStatoPortaCache(CostantiPdD.JMX_AUTORIZZAZIONE, infoAutorizzazioneDati.isCacheAbilitata());
  3241.             if(infoAutorizzazioneDati.isCacheAbilitata()){
  3242.                 informazioniStatoPortaCacheAutorizzazioneDati.setStatoCache(infoAutorizzazioneDati.printStatCache());
  3243.             }
  3244.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheAutorizzazioneDati);
  3245.             
  3246.             org.openspcoop2.pdd.core.jmx.EngineAutenticazione infoAutenticazioneDati = new org.openspcoop2.pdd.core.jmx.EngineAutenticazione();
  3247.             InformazioniStatoPortaCache informazioniStatoPortaCacheAutenticazioneDati = new InformazioniStatoPortaCache(CostantiPdD.JMX_AUTENTICAZIONE, infoAutenticazioneDati.isCacheAbilitata());
  3248.             if(infoAutenticazioneDati.isCacheAbilitata()){
  3249.                 informazioniStatoPortaCacheAutenticazioneDati.setStatoCache(infoAutenticazioneDati.printStatCache());
  3250.             }
  3251.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheAutenticazioneDati);
  3252.             
  3253.             org.openspcoop2.pdd.core.jmx.EngineGestioneToken infoGestioneTokenDati = new org.openspcoop2.pdd.core.jmx.EngineGestioneToken();
  3254.             InformazioniStatoPortaCache informazioniStatoPortaCacheGestioneTokenDati = new InformazioniStatoPortaCache(CostantiPdD.JMX_TOKEN, infoGestioneTokenDati.isCacheAbilitata());
  3255.             if(infoGestioneTokenDati.isCacheAbilitata()){
  3256.                 informazioniStatoPortaCacheGestioneTokenDati.setStatoCache(infoGestioneTokenDati.printStatCache());
  3257.             }
  3258.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheGestioneTokenDati);
  3259.             
  3260.             org.openspcoop2.pdd.core.jmx.EngineAttributeAuthority infoAttributeAuthorityDati = new org.openspcoop2.pdd.core.jmx.EngineAttributeAuthority();
  3261.             InformazioniStatoPortaCache informazioniStatoPortaCacheAttributeAuthorityDati = new InformazioniStatoPortaCache(CostantiPdD.JMX_ATTRIBUTE_AUTHORITY, infoAttributeAuthorityDati.isCacheAbilitata());
  3262.             if(infoAttributeAuthorityDati.isCacheAbilitata()){
  3263.                 informazioniStatoPortaCacheAttributeAuthorityDati.setStatoCache(infoAttributeAuthorityDati.printStatCache());
  3264.             }
  3265.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheAttributeAuthorityDati);
  3266.             
  3267.             org.openspcoop2.pdd.core.jmx.EngineResponseCaching infoResponseCaching = new org.openspcoop2.pdd.core.jmx.EngineResponseCaching();
  3268.             InformazioniStatoPortaCache informazioniStatoPortaCacheResponseCaching = new InformazioniStatoPortaCache(CostantiPdD.JMX_RESPONSE_CACHING, infoResponseCaching.isCacheAbilitata());
  3269.             if(infoResponseCaching.isCacheAbilitata()){
  3270.                 informazioniStatoPortaCacheResponseCaching.setStatoCache(infoResponseCaching.printStatCache());
  3271.             }
  3272.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheResponseCaching);
  3273.             
  3274.             org.openspcoop2.pdd.core.jmx.EngineKeystoreCaching infoKeystoreCaching = new org.openspcoop2.pdd.core.jmx.EngineKeystoreCaching();
  3275.             InformazioniStatoPortaCache informazioniStatoPortaCacheKeystoreCaching = new InformazioniStatoPortaCache(CostantiPdD.JMX_KEYSTORE_CACHING, infoKeystoreCaching.isCacheAbilitata());
  3276.             if(infoKeystoreCaching.isCacheAbilitata()){
  3277.                 informazioniStatoPortaCacheKeystoreCaching.setStatoCache(infoKeystoreCaching.printStatCache());
  3278.             }
  3279.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheKeystoreCaching);
  3280.             
  3281.             org.openspcoop2.pdd.core.jmx.GestoreConsegnaApplicativi infoGestoreConsegnaApplicativi = new org.openspcoop2.pdd.core.jmx.GestoreConsegnaApplicativi();
  3282.             InformazioniStatoPortaCache informazioniStatoPortaCacheGestoreConsegnaApplicativi = new InformazioniStatoPortaCache(CostantiPdD.JMX_LOAD_BALANCER, infoGestoreConsegnaApplicativi.isCacheAbilitata());
  3283.             if(infoGestoreConsegnaApplicativi.isCacheAbilitata()){
  3284.                 informazioniStatoPortaCacheGestoreConsegnaApplicativi.setStatoCache(infoGestoreConsegnaApplicativi.printStatCache());
  3285.             }
  3286.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheGestoreConsegnaApplicativi);
  3287.             
  3288.             org.openspcoop2.pdd.core.jmx.GestoreRichieste infoGestoreRichieste = new org.openspcoop2.pdd.core.jmx.GestoreRichieste();
  3289.             InformazioniStatoPortaCache informazioniStatoPortaCacheGestoreRichieste = new InformazioniStatoPortaCache(CostantiPdD.JMX_GESTORE_RICHIESTE, infoGestoreRichieste.isCacheAbilitata());
  3290.             if(infoGestoreRichieste.isCacheAbilitata()){
  3291.                 informazioniStatoPortaCacheGestoreRichieste.setStatoCache(infoGestoreRichieste.printStatCache());
  3292.             }
  3293.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheGestoreRichieste);
  3294.             
  3295.             org.openspcoop2.pdd.core.jmx.RepositoryMessaggi infoRepositoryMessaggi = new org.openspcoop2.pdd.core.jmx.RepositoryMessaggi();
  3296.             InformazioniStatoPortaCache informazioniStatoPortaCacheRepositoryMessaggi = new InformazioniStatoPortaCache(CostantiPdD.JMX_REPOSITORY_MESSAGGI, infoRepositoryMessaggi.isCacheAbilitata());
  3297.             if(infoRepositoryMessaggi.isCacheAbilitata()){
  3298.                 informazioniStatoPortaCacheRepositoryMessaggi.setStatoCache(infoRepositoryMessaggi.printStatCache());
  3299.             }
  3300.             informazioniStatoPortaCache.add(informazioniStatoPortaCacheRepositoryMessaggi);
  3301.             
  3302.             ConfigurazioneSistema infoConfigSistema = new ConfigurazioneSistema();
  3303.             ConfigurazioneSistema.setIncludePassword(propertiesReader.isConfigurazioneSistema_javaProperties_showPassword());
  3304.             StatoServiziJMXResource statoServiziPdD = new StatoServiziJMXResource();
  3305.             OpenSPCoop2Logger.getLoggerOpenSPCoopConfigurazioneSistema().
  3306.                 info(informazioniStatoPorta.formatStatoPorta(infoConfigSistema.getVersionePdD(), 
  3307.                         infoConfigSistema.getVersioneBaseDati(), infoConfigSistema.getDirectoryConfigurazione(), 
  3308.                         infoConfigSistema.getVersioneJava(), infoConfigSistema.getVendorJava(), infoConfigSistema.getMessageFactory(),
  3309.                         statoServiziPdD.getComponentePD(), statoServiziPdD.getComponentePD_abilitazioniPuntuali(), statoServiziPdD.getComponentePD_disabilitazioniPuntuali(),
  3310.                         statoServiziPdD.getComponentePA(), statoServiziPdD.getComponentePA_abilitazioniPuntuali(), statoServiziPdD.getComponentePA_disabilitazioniPuntuali(),
  3311.                         statoServiziPdD.getComponenteIM(),
  3312.                         LogLevels.toOpenSPCoop2(configurazionePdDManager.getSeveritaMessaggiDiagnostici(),true),
  3313.                         LogLevels.toOpenSPCoop2(configurazionePdDManager.getSeveritaLog4JMessaggiDiagnostici(),true),
  3314.                         OpenSPCoop2Logger.loggerMsgDiagnosticoAbilitato, OpenSPCoop2Logger.loggerMsgDiagnosticoReadableAbilitato, OpenSPCoop2Logger.loggerIntegrationManagerAbilitato,
  3315.                         configurazionePdDManager.tracciamentoBuste(), 
  3316.                         configurazionePdDManager.dumpBinarioPD(), configurazionePdDManager.dumpBinarioPA(),
  3317.                         OpenSPCoop2Logger.loggerTracciamentoAbilitato, OpenSPCoop2Logger.loggerDumpAbilitato,
  3318.                         propertiesReader.getFileTraceGovWayState().toString(),
  3319.                         ErroriProperties.isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_BAD_REQUEST(), 
  3320.                         (ErroriProperties.isFORCE_SPECIFIC_ERROR_TYPE_FOR_BAD_RESPONSE() && ErroriProperties.isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_RESPONSE_ERROR()),
  3321.                         ErroriProperties.isFORCE_SPECIFIC_ERROR_TYPE_FOR_INTERNAL_ERROR(),
  3322.                         Costanti.isTRANSACTION_ERROR_STATUS_ABILITATO(), Costanti.isTRANSACTION_ERROR_SOAP_USE_GOVWAY_STATUS_AS_FAULT_CODE(),
  3323.                         Costanti.isTRANSACTION_FORCE_SPECIFIC_ERROR_DETAILS(), Costanti.isTRANSACTION_ERROR_INSTANCE_ID_ABILITATO(), Costanti.isTRANSACTION_ERROR_SOAP_GENERATE_HTTP_HEADER_GOVWAY_CODE(),
  3324.                         infoConfigSistema.getInformazioniDatabase(), infoConfigSistema.getInformazioniAltriDatabase(),
  3325.                         infoConfigSistema.getInformazioniSSL(true,true,true,true),
  3326.                         infoConfigSistema.getInformazioniCryptographyKeyLength(),
  3327.                         infoConfigSistema.getInformazioniCharset(),
  3328.                         infoConfigSistema.getInformazioniInternazionalizzazione(true),
  3329.                         infoConfigSistema.getInformazioniTimeZone(true),
  3330.                         infoConfigSistema.getInformazioniProprietaJava(true, true, false, ConfigurazioneSistema.isIncludePassword()),
  3331.                         infoConfigSistema.getInformazioniProprietaJava(true, false, true, ConfigurazioneSistema.isIncludePassword()),
  3332.                         infoConfigSistema.getInformazioniProprietaSistema(),
  3333.                         infoConfigSistema.getPluginProtocols(), 
  3334.                         infoConfigSistema.getInformazioniInstallazione(),
  3335.                         informazioniStatoPortaCache.toArray(new InformazioniStatoPortaCache[1])));

  3337.             
  3338.             
  3339.             
  3340.             
  3341.             
  3342.     
  3343.             
  3344.             
  3345.             
  3346.             // Inizializzazione Init Handler
  3347.             try{
  3348.                 InitContext initContext = new InitContext();
  3349.                 initContext.setLogCore(logCore);
  3350.                 initContext.setLogConsole(OpenSPCoop2Startup.log);
  3351.                 initContext.setPddContext(OpenSPCoop2Startup.this.pddContext);
  3352.                 GestoreHandlers.init(initContext, msgDiag,OpenSPCoop2Startup.log); // per avere gli init stampati su server log
  3353.             }catch(HandlerException e){
  3354.                 if(e.isEmettiDiagnostico()){
  3355.                     msgDiag.logStartupError(e,e.getIdentitaHandler());
  3356.                 }
  3357.                 else{
  3358.                     logCore.error(e.getMessage(),e);
  3359.                 }
  3360.                 return;
  3361.             }catch(Exception e){
  3362.                 msgDiag.logStartupError(e,"InitHandler");
  3363.                 return;
  3364.             }
  3365.             
  3366.             
  3367.             
  3368.             
  3369.             



  3373.             // Inizializzazione Timer per il check delle risorse
  3374.             try{
  3375.                 if( propertiesReader.isAbilitatoControlloRisorseConfigurazione() ||
  3376.                         propertiesReader.isAbilitatoControlloValidazioneSemanticaConfigurazione() ||
  3377.                         propertiesReader.isAbilitatoControlloRisorseDB() ||
  3378.                         propertiesReader.isAbilitatoControlloRisorseJMS() ||
  3379.                         propertiesReader.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() || 
  3380.                         propertiesReader.isAbilitatoControlloRisorseRegistriServizi() ||
  3381.                         propertiesReader.isAbilitatoControlloValidazioneSemanticaRegistriServizi() ||
  3382.                         propertiesReader.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
  3383.                     OpenSPCoop2Startup.this.timerMonitoraggioRisorse = new TimerMonitoraggioRisorseThread();
  3384.                     OpenSPCoop2Startup.this.timerMonitoraggioRisorse.start();
  3385.                     TimerMonitoraggioRisorseThread.setSTATE( TimerState.ENABLED );
  3386.                     OpenSPCoop2Startup.logStartupInfo("Inizializzo Timer per il Monitoraggio delle Risorse");
  3387.                 }
  3388.             }catch(Exception e){
  3389.                 msgDiag.logStartupError(e,"TimerMonitoraggioRisorse");
  3390.                 return;
  3391.             }





  3397.             // Inizializzazione Timer per il check del Threshold
  3398.             try{
  3399.                 List<String> tipiThreshold = propertiesReader.getRepositoryThresholdTypes();
  3400.                 if(tipiThreshold!=null && !tipiThreshold.isEmpty()){
  3401.                     OpenSPCoop2Startup.this.timerThreshold = new TimerThresholdThread();
  3402.                     OpenSPCoop2Startup.this.timerThreshold.start();
  3403.                     TimerThresholdThread.setSTATE( TimerState.ENABLED );
  3404.                     OpenSPCoop2Startup.logStartupInfo("Inizializzo Timer per il Controllo dei Threshold sulle risorse");
  3405.                 }
  3406.             }catch(Exception e){
  3407.                 msgDiag.logStartupError(e,"TimerThreshold");
  3408.                 return;
  3409.             }






  3416.             // Inizializzazione delle risorse esterne terminata
  3417.             OpenSPCoop2Startup.initialize = true;
  3418.             Utilities.sleep(1000);








  3427.             /* -------- Check deploy timer ------ */
  3428.             boolean gestoreBusteNonRiscontrate = false;
  3429.             boolean gestoreMessaggi = false;
  3430.             boolean gestorePuliziaMessaggiAnomali = false;
  3431.             boolean gestoreRepository=false;
  3432.             if(OpenSPCoop2Startup.this.serverJ2EE){
  3433.                 long scadenzaWhile = System.currentTimeMillis() + propertiesReader.getTimerEJBDeployTimeout();
  3434.                 GestoreJNDI jndi = null;
  3435.                 if(propertiesReader.getJNDIContext_TimerEJB()==null)
  3436.                     jndi = new GestoreJNDI();
  3437.                 else
  3438.                     jndi = new GestoreJNDI(propertiesReader.getJNDIContext_TimerEJB());

  3440.                 while( (System.currentTimeMillis() < scadenzaWhile)
  3441.                         && 
  3442.                         (gestoreBusteNonRiscontrate==false
  3443.                                 || gestoreMessaggi==false
  3444.                                 || gestorePuliziaMessaggiAnomali==false
  3445.                                 || gestoreRepository==false)){

  3447.                     gestoreBusteNonRiscontrate = false;
  3448.                     gestoreMessaggi = false;
  3449.                     gestorePuliziaMessaggiAnomali = false;
  3450.                     gestoreRepository=false;

  3452.                     // check Timer Gestore Riscontri
  3453.                     if(propertiesReader.isTimerGestoreRiscontriRicevuteAbilitato()){
  3454.                         try{
  3455.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreBusteNonRiscontrate.ID_MODULO);
  3456.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore riscontri ["+nomeJNDI+"]");
  3457.                             jndi.lookup(nomeJNDI);
  3458.                             gestoreBusteNonRiscontrate = true;
  3459.                         }catch(Exception e){
  3460.                             this.logError("Search EJB gestore riscontri non trovato: "+e.getMessage(),e);
  3461.                             try {
  3462.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3463.                             }catch(Exception eRandom){
  3464.                                 // ignore
  3465.                             }
  3466.                             continue;
  3467.                         }
  3468.                     }else{
  3469.                         gestoreBusteNonRiscontrate = true;
  3470.                     }

  3472.                     //  check Timer Gestore Messaggi
  3473.                     if(propertiesReader.isTimerGestoreMessaggiAbilitato()){
  3474.                         try{
  3475.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreMessaggi.ID_MODULO);
  3476.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore messaggi ["+nomeJNDI+"]");
  3477.                             jndi.lookup(nomeJNDI);
  3478.                             gestoreMessaggi = true;
  3479.                         }catch(Exception e){
  3480.                             this.logError("Search EJB gestore messaggi non trovato: "+e.getMessage(),e);
  3481.                             try{
  3482.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3483.                             }catch(Exception eRandom){
  3484.                                 // ignore
  3485.                             }
  3486.                             continue;
  3487.                         }
  3488.                     }else{
  3489.                         gestoreMessaggi = true;
  3490.                     }

  3492.                     //  check Timer Gestore Pulizia Messaggi Anomali
  3493.                     if(propertiesReader.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
  3494.                         try{
  3495.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestorePuliziaMessaggiAnomali.ID_MODULO);
  3496.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore pulizia messaggi anomali ["+nomeJNDI+"]");
  3497.                             jndi.lookup(nomeJNDI);
  3498.                             gestorePuliziaMessaggiAnomali = true;
  3499.                         }catch(Exception e){
  3500.                             this.logError("Search EJB pulizia messaggi anomali non trovato: "+e.getMessage(),e);
  3501.                             try{
  3502.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3503.                             }catch(Exception eRandom){
  3504.                                 // ignore
  3505.                             }
  3506.                             continue;
  3507.                         }
  3508.                     }else{
  3509.                         gestorePuliziaMessaggiAnomali = true;
  3510.                     }


  3513.                     //  check Timer Gestore Repository
  3514.                     if(propertiesReader.isTimerGestoreRepositoryBusteAbilitato()){
  3515.                         try{
  3516.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreRepositoryBuste.ID_MODULO);
  3517.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore repository ["+nomeJNDI+"]");
  3518.                             jndi.lookup(nomeJNDI);
  3519.                             gestoreRepository = true;
  3520.                         }catch(Exception e){
  3521.                             this.logError("Search EJB gestore repository non trovato: "+e.getMessage(),e);
  3522.                             try{
  3523.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3524.                             }catch(Exception eRandom){
  3525.                                 // ignore
  3526.                             }
  3527.                             continue;
  3528.                         }
  3529.                     }else{
  3530.                         gestoreRepository = true;
  3531.                     }
  3532.                 }
  3533.             }






  3540.             /* ------------ Avvia il thread per la gestione dei Riscontri Scaduti  ------------ */
  3541.             if(OpenSPCoop2Startup.this.serverJ2EE){
  3542.                 if(propertiesReader.isTimerGestoreRiscontriRicevuteAbilitato()){
  3543.                     if(gestoreBusteNonRiscontrate){
  3544.                         try{
  3545.                             OpenSPCoop2Startup.this.timerRiscontri = TimerUtils.createTimerGestoreBusteNonRiscontrate();
  3546.                         }catch(Exception e){
  3547.                             msgDiag.logStartupError(e,"Creazione timer '"+TimerGestoreBusteNonRiscontrate.ID_MODULO+"'");
  3548.                         }
  3549.                         if(OpenSPCoop2Startup.this.timerRiscontri != null) {
  3550.                             try {
  3551.                                 OpenSPCoop2Startup.this.timerRiscontri.start();
  3552.                                 TimerGestoreBusteNonRiscontrateLib.setSTATE_ONEWAY( TimerState.ENABLED );
  3553.                                 TimerGestoreBusteNonRiscontrateLib.setSTATE_ASINCRONI( TimerState.ENABLED );
  3554.                             } catch (RemoteException e) {
  3555.                                 msgDiag.logStartupError(e,"Avvio timer '"+TimerGestoreBusteNonRiscontrate.ID_MODULO+"'");
  3556.                             }
  3557.                         }else{
  3558.                             msgDiag.logStartupError("timer is null","Avvio timer '"+TimerGestoreBusteNonRiscontrate.ID_MODULO+"'");
  3559.                         }
  3560.                     }else{
  3561.                         msgDiag.logStartupError("timer non esiste nell'application server","Avvio timer '"+TimerGestoreBusteNonRiscontrate.ID_MODULO+"'");
  3562.                     }
  3563.                 }else{
  3564.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_RISCONTRI_RICEVUTE);
  3565.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI, TimerGestoreBusteNonRiscontrate.ID_MODULO);
  3566.                     msgDiag.logPersonalizzato("disabilitato");
  3567.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3568.                 }
  3569.             }









  3579.             /* ------------ Avvia il thread per l'eliminazione dei messaggi  ------------ */
  3580.             if(propertiesReader.isTimerGestoreMessaggiAbilitato()){
  3581.                 if(OpenSPCoop2Startup.this.serverJ2EE){
  3582.                     if(gestoreMessaggi){
  3583.                         try{
  3584.                             OpenSPCoop2Startup.this.timerEliminazioneMsg = TimerUtils.createTimerGestoreMessaggi();
  3585.                         }catch(Exception e){
  3586.                             msgDiag.logStartupError(e,"Creazione timer '"+TimerGestoreMessaggi.ID_MODULO+"'");
  3587.                         }
  3588.                         if(OpenSPCoop2Startup.this.timerEliminazioneMsg != null) {
  3589.                             try {
  3590.                                 OpenSPCoop2Startup.this.timerEliminazioneMsg.start();
  3591.                                 TimerGestoreMessaggiLib.setSTATE_MESSAGGI_ELIMINATI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3592.                                 TimerGestoreMessaggiLib.setSTATE_MESSAGGI_SCADUTI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3593.                                 TimerGestoreMessaggiLib.setSTATE_MESSAGGI_NON_GESTITI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3594.                                 TimerGestoreMessaggiLib.setSTATE_CORRELAZIONE_APPLICATIVA( propertiesReader.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3595.                                 TimerGestoreMessaggiLib.setSTATE_VERIFICA_CONNESSIONI_ATTIVE( propertiesReader.isTimerGestoreMessaggiVerificaConnessioniAttive() ? TimerState.ENABLED : TimerState.DISABLED );
  3596.                             } catch (RemoteException e) {
  3597.                                 msgDiag.logStartupError(e,"Avvio timer '"+TimerGestoreMessaggi.ID_MODULO+"'");
  3598.                             }
  3599.                         }else{
  3600.                             msgDiag.logStartupError("timer is null","Avvio timer '"+TimerGestoreMessaggi.ID_MODULO+"'");
  3601.                         }
  3602.                     }else{
  3603.                         msgDiag.logStartupError("timer non esiste nell'application server","Avvio timer '"+TimerGestoreMessaggi.ID_MODULO+"'");
  3604.                     }
  3605.                 }else{
  3606.                     try{
  3607.                         OpenSPCoop2Startup.this.threadEliminazioneMsg = new TimerGestoreMessaggiThread();
  3608.                         OpenSPCoop2Startup.this.threadEliminazioneMsg.start();
  3609.                         TimerGestoreMessaggiLib.setSTATE_MESSAGGI_ELIMINATI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiEliminatiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3610.                         TimerGestoreMessaggiLib.setSTATE_MESSAGGI_SCADUTI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiScadutiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3611.                         TimerGestoreMessaggiLib.setSTATE_MESSAGGI_NON_GESTITI( propertiesReader.isTimerGestoreMessaggiPuliziaMessaggiNonGestitiAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3612.                         TimerGestoreMessaggiLib.setSTATE_CORRELAZIONE_APPLICATIVA( propertiesReader.isTimerGestoreMessaggiPuliziaCorrelazioneApplicativaAbilitata() ? TimerState.ENABLED : TimerState.DISABLED );
  3613.                         TimerGestoreMessaggiLib.setSTATE_VERIFICA_CONNESSIONI_ATTIVE( propertiesReader.isTimerGestoreMessaggiVerificaConnessioniAttive() ? TimerState.ENABLED : TimerState.DISABLED );
  3614.                     }catch(Exception e){
  3615.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestoreMessaggi.ID_MODULO+"'");
  3616.                     }
  3617.                 }
  3618.             }else{
  3619.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_MESSAGGI);
  3620.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI, TimerGestoreMessaggi.ID_MODULO);
  3621.                 msgDiag.logPersonalizzato("disabilitato");
  3622.                 msgDiag.setPrefixMsgPersonalizzati(null);
  3623.             }









  3633.             /* ------------ Avvia il thread per l'eliminazione dei messaggi anomali ------------ */
  3634.             if(propertiesReader.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
  3635.                 if(OpenSPCoop2Startup.this.serverJ2EE){
  3636.                     if(gestorePuliziaMessaggiAnomali){
  3637.                         try{
  3638.                             OpenSPCoop2Startup.this.timerPuliziaMsgAnomali = TimerUtils.createTimerGestorePuliziaMessaggiAnomali();
  3639.                         }catch(Exception e){
  3640.                             msgDiag.logStartupError(e,"Creazione timer '"+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"'");
  3641.                         }
  3642.                         if(OpenSPCoop2Startup.this.timerPuliziaMsgAnomali != null) {
  3643.                             try {
  3644.                                 OpenSPCoop2Startup.this.timerPuliziaMsgAnomali.start();
  3645.                                 TimerGestorePuliziaMessaggiAnomaliLib.setSTATE( TimerState.ENABLED );
  3646.                             } catch (RemoteException e) {
  3647.                                 msgDiag.logStartupError(e,"Avvio timer '"+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"'");
  3648.                             }
  3649.                         }else{
  3650.                             msgDiag.logStartupError("timer is null","Avvio timer '"+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"'");
  3651.                         }
  3652.                     }else{
  3653.                         msgDiag.logStartupError("timer non esiste nell'application server","Avvio timer '"+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"'");
  3654.                     }
  3655.                 }else{
  3656.                     try{
  3657.                         OpenSPCoop2Startup.this.threadPuliziaMsgAnomali = new TimerGestorePuliziaMessaggiAnomaliThread();
  3658.                         OpenSPCoop2Startup.this.threadPuliziaMsgAnomali.start();
  3659.                         TimerGestorePuliziaMessaggiAnomaliLib.setSTATE( TimerState.ENABLED );
  3660.                     }catch(Exception e){
  3661.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestorePuliziaMessaggiAnomali.ID_MODULO+"'");
  3662.                     }
  3663.                 }
  3664.             }else{
  3665.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_MESSAGGI_INCONSISTENTI);
  3666.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_MESSAGGI_INCONSISTENTI, TimerGestorePuliziaMessaggiAnomali.ID_MODULO);
  3667.                 msgDiag.logPersonalizzato("disabilitato");
  3668.                 msgDiag.setPrefixMsgPersonalizzati(null);
  3669.             }







  3677.             /* ------------ Avvia il thread per l'eliminazione delle buste  ------------ */
  3678.             if(propertiesReader.isTimerGestoreRepositoryBusteAbilitato()){
  3679.                 if(OpenSPCoop2Startup.this.serverJ2EE){
  3680.                     if(gestoreRepository){
  3681.                         try{
  3682.                             OpenSPCoop2Startup.this.timerRepositoryBuste = TimerUtils.createTimerGestoreRepositoryBuste();
  3683.                         }catch(Exception e){
  3684.                             msgDiag.logStartupError(e,"Creazione timer '"+TimerGestoreRepositoryBuste.ID_MODULO+"'");
  3685.                         }
  3686.                         if(OpenSPCoop2Startup.this.timerRepositoryBuste != null) {
  3687.                             try {
  3688.                                 OpenSPCoop2Startup.this.timerRepositoryBuste.start();
  3689.                                 TimerGestoreRepositoryBusteLib.setSTATE( propertiesReader.isTimerGestoreRepositoryBusteAbilitatoInitialState() ? TimerState.ENABLED : TimerState.DISABLED );
  3690.                             } catch (RemoteException e) {
  3691.                                 msgDiag.logStartupError(e,"Avvio timer '"+TimerGestoreRepositoryBuste.ID_MODULO+"'");
  3692.                             }
  3693.                         }else{
  3694.                             msgDiag.logStartupError("timer is null","Avvio timer '"+TimerGestoreRepositoryBuste.ID_MODULO+"'");
  3695.                         }
  3696.                     }else{
  3697.                         msgDiag.logStartupError("timer non esiste nell'application server","Avvio timer '"+TimerGestoreRepositoryBuste.ID_MODULO+"'");
  3698.                     }
  3699.                 }else{
  3700.                     try{
  3701.                         OpenSPCoop2Startup.this.threadRepositoryBuste = new TimerGestoreRepositoryBusteThread();
  3702.                         OpenSPCoop2Startup.this.threadRepositoryBuste.start();
  3703.                         TimerGestoreRepositoryBusteLib.setSTATE( propertiesReader.isTimerGestoreRepositoryBusteAbilitatoInitialState() ? TimerState.ENABLED : TimerState.DISABLED );
  3704.                     }catch(Exception e){
  3705.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestoreRepositoryBuste.ID_MODULO+"'");
  3706.                     }
  3707.                 }
  3708.             }else{
  3709.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_REPOSITORY_BUSTE);
  3710.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER_GESTORE_REPOSITORY_BUSTE, TimerGestoreRepositoryBuste.ID_MODULO);
  3711.                 msgDiag.logPersonalizzato("disabilitato");
  3712.                 msgDiag.setPrefixMsgPersonalizzati(null);
  3713.             }




  3718.             
  3719.             
  3720.             
  3721.             
  3722.             
  3723.             /* ------------ Avvia il thread per la riconsegna dei messaggi per ContenutiApplicativi  ------------ */
  3724.             if(OpenSPCoop2Startup.this.serverJ2EE==false){
  3725.                 if(propertiesReader.isTimerConsegnaContenutiApplicativiAbilitato()){
  3726.                     OpenSPCoop2Startup.this.threadConsegnaContenutiApplicativiMap = new HashMap<String, TimerConsegnaContenutiApplicativiThread>();
  3727.                     List<String> code = propertiesReader.getTimerConsegnaContenutiApplicativiCode();
  3728.                     try{
  3729.                         for (String coda : code) {
  3730.                             ConfigurazioneCoda configurazioneCoda = propertiesReader.getTimerConsegnaContenutiApplicativiConfigurazioneCoda(coda);
  3731.                             TimerConsegnaContenutiApplicativiThread timer = new TimerConsegnaContenutiApplicativiThread(configurazioneCoda);
  3732.                             timer.start();
  3733.                             OpenSPCoop2Startup.this.threadConsegnaContenutiApplicativiMap.put(coda, timer);
  3734.                         }
  3735.                         TimerConsegnaContenutiApplicativi.setSTATE( TimerState.ENABLED );
  3736.                     }catch(Exception e){
  3737.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerConsegnaContenutiApplicativiThread.ID_MODULO+"'");
  3738.                     }
  3739.                     OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap = OpenSPCoop2Startup.this.threadConsegnaContenutiApplicativiMap;
  3740.                 }else{
  3741.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_CONSEGNA_CONTENUTI_APPLICATIVI);
  3742.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerConsegnaContenutiApplicativiThread.ID_MODULO);
  3743.                     msgDiag.logPersonalizzato("disabilitato");
  3744.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3745.                 }
  3746.             }
  3747.             
  3748.             
  3749.             
  3750.             
  3751.             
  3752.             
  3753.             /* ------------ Avvia il thread per la generazione delle statistiche  ------------ */
  3754.             if(propertiesReader.isStatisticheGenerazioneEnabled()){
  3755.                 
  3756.                 // stat orarie
  3757.                 String idTimerStatOrarie = "Timer"+TipoIntervalloStatistico.STATISTICHE_ORARIE.getValue();
  3758.                 if(propertiesReader.isStatisticheGenerazioneBaseOrariaEnabled()) {
  3759.                     try{
  3760.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie = 
  3761.                                 new TimerStatisticheThread(propertiesReader.getStatisticheOrarieGenerazioneTimerIntervalSeconds(), TipoIntervalloStatistico.STATISTICHE_ORARIE);
  3762.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie.start();
  3763.                         TimerStatisticheLib.setSTATE_STATISTICHE_ORARIE( TimerState.ENABLED );
  3764.                     }catch(Exception e){
  3765.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerStatOrarie+"'");
  3766.                     }
  3767.                 }else{
  3768.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3769.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerStatOrarie);
  3770.                     msgDiag.logPersonalizzato("disabilitato");
  3771.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3772.                 }
  3773.                 
  3774.                 // stat giornaliere
  3775.                 String idTimerStatGiornaliere = "Timer"+TipoIntervalloStatistico.STATISTICHE_GIORNALIERE.getValue();
  3776.                 if(propertiesReader.isStatisticheGenerazioneBaseGiornalieraEnabled()) {
  3777.                     try{
  3778.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere = 
  3779.                                 new TimerStatisticheThread(propertiesReader.getStatisticheGiornaliereGenerazioneTimerIntervalSeconds(), TipoIntervalloStatistico.STATISTICHE_GIORNALIERE);
  3780.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere.start();
  3781.                         TimerStatisticheLib.setSTATE_STATISTICHE_GIORNALIERE( TimerState.ENABLED );
  3782.                     }catch(Exception e){
  3783.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerStatGiornaliere+"'");
  3784.                     }
  3785.                 }else{
  3786.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3787.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerStatGiornaliere);
  3788.                     msgDiag.logPersonalizzato("disabilitato");
  3789.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3790.                 }
  3791.                 
  3792.                 // stat settimanali
  3793.                 String idTimerStatSettimanali = "Timer"+TipoIntervalloStatistico.STATISTICHE_SETTIMANALI.getValue();
  3794.                 if(propertiesReader.isStatisticheGenerazioneBaseSettimanaleEnabled()) {
  3795.                     try{
  3796.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali = 
  3797.                                 new TimerStatisticheThread(propertiesReader.getStatisticheSettimanaliGenerazioneTimerIntervalSeconds(), TipoIntervalloStatistico.STATISTICHE_SETTIMANALI);
  3798.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali.start();
  3799.                         TimerStatisticheLib.setSTATE_STATISTICHE_SETTIMANALI( TimerState.ENABLED );
  3800.                     }catch(Exception e){
  3801.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerStatSettimanali+"'");
  3802.                     }
  3803.                 }else{
  3804.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3805.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerStatSettimanali);
  3806.                     msgDiag.logPersonalizzato("disabilitato");
  3807.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3808.                 }
  3809.                 
  3810.                 // stat mensili
  3811.                 String idTimerStatMensili = "Timer"+TipoIntervalloStatistico.STATISTICHE_MENSILI.getValue();
  3812.                 if(propertiesReader.isStatisticheGenerazioneBaseMensileEnabled()) {
  3813.                     try{
  3814.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili = 
  3815.                                 new TimerStatisticheThread(propertiesReader.getStatisticheMensiliGenerazioneTimerIntervalSeconds(), TipoIntervalloStatistico.STATISTICHE_MENSILI);
  3816.                         OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili.start();
  3817.                         TimerStatisticheLib.setSTATE_STATISTICHE_MENSILI( TimerState.ENABLED );
  3818.                     }catch(Exception e){
  3819.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerStatMensili+"'");
  3820.                     }
  3821.                 }else{
  3822.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3823.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerStatMensili);
  3824.                     msgDiag.logPersonalizzato("disabilitato");
  3825.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3826.                 }
  3827.                 
  3828.                 // pdnd generazione tracciamento
  3829.                 String idTimerPdndTracciamentoGenerazione = "Timer"+TipoIntervalloStatistico.PDND_GENERAZIONE_TRACCIAMENTO.getValue();
  3830.                 if(ModIUtils.isTracingPDNDEnabledSafe() && propertiesReader.isStatistichePdndTracciamentoGenerazioneEnabled()) {
  3831.                     try{
  3832.                         OpenSPCoop2Startup.this.threadPdndTracciamentoGenerazione = 
  3833.                                 new TimerStatisticheThread(propertiesReader.getStatistichePdndTracciamentoGenerazioneTimerIntervalSeconds(), TipoIntervalloStatistico.PDND_GENERAZIONE_TRACCIAMENTO);
  3834.                         OpenSPCoop2Startup.this.threadPdndTracciamentoGenerazione.start();
  3835.                         TimerStatisticheLib.setSTATE_PDND_TRACCIAMENTO_GENERAZIONE(TimerState.ENABLED);
  3836.                     }catch(Exception e){
  3837.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerPdndTracciamentoGenerazione+"'");
  3838.                     }
  3839.                 }else{
  3840.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3841.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerPdndTracciamentoGenerazione);
  3842.                     msgDiag.logPersonalizzato("disabilitato");
  3843.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3844.                 }
  3845.                 
  3846.                 // pdnd generazione pubblicazione
  3847.                 String idTimerPdndTracciamentoPubblicazione = "Timer"+TipoIntervalloStatistico.PDND_PUBBLICAZIONE_TRACCIAMENTO.getValue();
  3848.                 if(ModIUtils.isTracingPDNDEnabledSafe() && propertiesReader.isStatistichePdndTracciamentoPubblicazioneEnabled()) {
  3849.                     try{
  3850.                         OpenSPCoop2Startup.this.threadPdndTracciamentoPubblicazione = 
  3851.                                 new TimerStatisticheThread(propertiesReader.getStatistichePdndTracciamentoPubblicazioneTimerIntervalSeconds(), TipoIntervalloStatistico.PDND_PUBBLICAZIONE_TRACCIAMENTO);
  3852.                         OpenSPCoop2Startup.this.threadPdndTracciamentoPubblicazione.start();
  3853.                         TimerStatisticheLib.setSTATE_PDND_TRACCIAMENTO_PUBBLICAZIONE(TimerState.ENABLED);
  3854.                     }catch(Exception e){
  3855.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+idTimerPdndTracciamentoPubblicazione+"'");
  3856.                     }
  3857.                 }else{
  3858.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3859.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, idTimerPdndTracciamentoPubblicazione);
  3860.                     msgDiag.logPersonalizzato("disabilitato");
  3861.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3862.                 }
  3863.             }
  3864.             else{
  3865.                 // Tutti i timers sono disabilitati
  3866.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_STATISTICHE);
  3867.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerStatisticheThread.ID_MODULO);
  3868.                 msgDiag.logPersonalizzato("disabilitato");
  3869.                 msgDiag.setPrefixMsgPersonalizzati(null);
  3870.             }
  3871.             
  3872.             
  3873.             
  3874.         
  3875.             
  3876.             /* ------------ Avvia il thread per la gestione delle chiavi PDND ------------ */
  3877.             if(protocolFactoryManager.existsProtocolFactory(CostantiLabel.MODIPA_PROTOCOL_NAME)) { // verifico che esista su PDND
  3878.                 
  3879.                 RemoteStoreProviderDriver.setKeyMaxLifeMinutes(propertiesReader.getGestoreChiaviPDNDkeysMaxLifeMinutes());
  3880.                 OpenSPCoop2Startup.logStartupInfo("PDND Key max life minutes: "+RemoteStoreProviderDriver.getKeyMaxLifeMinutes());
  3881.                 
  3882.                 RemoteStoreClientInfoCache.setClientDetailsMaxLifeMinutes(propertiesReader.getGestoreChiaviPDNDclientInfoMaxLifeMinutes());
  3883.                 OpenSPCoop2Startup.logStartupInfo("PDND ClientId details max life minutes: "+RemoteStoreClientInfoCache.getClientDetailsMaxLifeMinutes());
  3884.                 
  3885.                 RemoteStoreClientInfoCache.setClientDetailsCacheFallbackMaxLifeMinutes(propertiesReader.getGestoreChiaviPDNDclientInfoCacheFallbackMaxLifeMinutes());
  3886.                 OpenSPCoop2Startup.logStartupInfo("PDND ClientId details max life minutes (cache fallback): "+RemoteStoreClientInfoCache.getClientDetailsCacheFallbackMaxLifeMinutes());
  3887.                 
  3888.                 
  3889.                 List<PDNDConfig> listRemoteConfig = null;
  3890.                 try {
  3891.                     listRemoteConfig = PDNDConfigUtilities.getRemoteStoreConfig(propertiesReader);
  3892.                 }catch(Exception e){
  3893.                     String msgError = "Inizializzazione thread per la gestione delle chiavi PDND non riuscita: "+e.getMessage();
  3894.                     msgDiag.logStartupError(e,msgError);
  3895.                     return;
  3896.                 }
  3897.                 
  3898.                 if(listRemoteConfig!=null && !listRemoteConfig.isEmpty() && propertiesReader.isGestoreChiaviPDNDEnabled()) {
  3899.                     
  3900.                     OpenSPCoop2Startup.this.threadGestoreChiaviPDNDEnabled = true;
  3901.                     
  3902.                     try{
  3903.                         OpenSPCoop2Startup.this.threadGestoreChiaviPDND = 
  3904.                                 new TimerGestoreChiaviPDND(propertiesReader.getGestoreChiaviPDNDeventsKeysTimerIntervalloSecondi(), listRemoteConfig);
  3905.                         OpenSPCoop2Startup.this.threadGestoreChiaviPDND.start();
  3906.                         TimerGestoreChiaviPDNDLib.setState( TimerState.ENABLED );
  3907.                     }catch(Exception e){
  3908.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestoreChiaviPDND.ID_MODULO+"'");
  3909.                     }
  3910.                     
  3911.                     try{
  3912.                         OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND = 
  3913.                                 new TimerGestoreCacheChiaviPDND(propertiesReader.getGestoreChiaviPDNDcacheKeysTimerIntervalloSecondi(), listRemoteConfig);
  3914.                         OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND.start();
  3915.                         TimerGestoreCacheChiaviPDNDLib.setState( TimerState.ENABLED );
  3916.                     }catch(Exception e){
  3917.                         msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestoreCacheChiaviPDND.ID_MODULO+"'");
  3918.                     }
  3919.                 }
  3920.                 else {
  3921.                     msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_CHIAVI_PDND);
  3922.                     
  3923.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerGestoreChiaviPDND.ID_MODULO);
  3924.                     msgDiag.addKeyword(CostantiPdD.KEY_REMOTE_STORE, "-");
  3925.                     msgDiag.logPersonalizzato("disabilitato");
  3926.                     
  3927.                     msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerGestoreCacheChiaviPDND.ID_MODULO);
  3928.                     msgDiag.addKeyword(CostantiPdD.KEY_REMOTE_STORE, "-");
  3929.                     msgDiag.logPersonalizzato("disabilitato");
  3930.                     
  3931.                     msgDiag.setPrefixMsgPersonalizzati(null);
  3932.                 }
  3933.                 
  3934.             }
  3935.             
  3936.             
  3937.             
  3938.             
  3939.             
  3940.             
  3941.             /* ------------ Avvia il thread per la gestione delle operazioni remote in un cluster dinamico ------------ */
  3942.             
  3943.             if(propertiesReader.isProxyReadJMXResourcesEnabled() && propertiesReader.isProxyReadJMXResourcesAsyncProcessByTimer()) {
  3944.                 
  3945.                 OpenSPCoop2Startup.this.threadGestoreOperazioniRemoteEnabled = true;
  3946.                 
  3947.                 try{
  3948.                     OpenSPCoop2Startup.this.threadGestoreOperazioniRemote = 
  3949.                             new TimerGestoreOperazioniRemote(propertiesReader.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval());
  3950.                     OpenSPCoop2Startup.this.threadGestoreOperazioniRemote.start();
  3951.                     TimerGestoreOperazioniRemoteLib.setState( TimerState.ENABLED );
  3952.                 }catch(Exception e){
  3953.                     msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerGestoreOperazioniRemote.ID_MODULO+"'");
  3954.                 }
  3955.                 
  3956.                 try{
  3957.                     OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote = 
  3958.                             new TimerSvecchiamentoOperazioniRemote(propertiesReader.getProxyReadJMXResourcesAsyncProcessByTimerCheckOldRecordInterval());
  3959.                     OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote.start();
  3960.                     TimerSvecchiamentoOperazioniRemoteLib.setState( TimerState.ENABLED );
  3961.                 }catch(Exception e){
  3962.                     msgDiag.logStartupError(e,"Avvio timer (thread) '"+TimerSvecchiamentoOperazioniRemote.ID_MODULO+"'");
  3963.                 }
  3964.             }
  3965.             else {
  3966.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_GESTORE_OPERAZIONI_ASINCRONE);
  3967.                 
  3968.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerGestoreOperazioniRemote.ID_MODULO);
  3969.                 msgDiag.logPersonalizzato("disabilitato");
  3970.                 
  3971.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_TIMER_SVECCHIAMENTO_OPERAZIONI_ASINCRONE);
  3972.                 
  3973.                 msgDiag.addKeyword(CostantiPdD.KEY_TIMER, TimerSvecchiamentoOperazioniRemote.ID_MODULO);
  3974.                 msgDiag.logPersonalizzato("disabilitato");
  3975.                 
  3976.                 msgDiag.setPrefixMsgPersonalizzati(null);
  3977.             }
  3978.             
  3979.             
  3980.             
  3981.             
  3982.             /* ------------ Avvia il thread per la gestione Stateful delle transazioni ------------ */
  3983.             Logger forceLogTransazioniStateful = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniStateful(true);
  3984.             try{
  3985.                 boolean debug = propertiesReader.isTransazioniStatefulDebug();
  3986.                 
  3987.                 Logger logTransazioniStateful = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniStateful(debug);
  3988.                             
  3989.                 if(propertiesReader.isTransazioniStatefulEnabled()){
  3990.                     if(debug)
  3991.                         logTransazioniStateful.debug("Avvio inizializzazione thread per gestione transazioni stateful ...");
  3992.                     OpenSPCoop2Startup.this.threadRepositoryStateful = new TimerRepositoryStatefulThread();
  3993.                     OpenSPCoop2Startup.this.threadRepositoryStateful.start();
  3994.                     TimerRepositoryStatefulThread.setSTATE( TimerState.ENABLED );
  3995.                     forceLogTransazioniStateful.info("Thread per la gestione transazioni stateful avviato correttamente");
  3996.                 }
  3997.                 else{
  3998.                     forceLogTransazioniStateful.info("Thread per la gestione transazioni stateful disabilitato");
  3999.                 }
  4000.             
  4001.             }catch(Exception e){
  4002.                 String msgError = "Inizializzazione thread per la gestione transazioni stateful non riuscita: "+e.getMessage();
  4003.                 forceLogTransazioniStateful.error(msgError,e);
  4004.                 msgDiag.logStartupError(e,"Inizializzazione Gesotre Transazioni Stateful");
  4005.                 return;
  4006.             }
  4007.             
  4008.             
  4009.             
  4010.             
  4011.             /* ------------ Avvia il thread per il Recovery FileSystem ------------ */
  4012.             Logger forceLogRecoveryFileSystem = OpenSPCoop2Logger.getLoggerOpenSPCoopFileSystemRecovery(true);
  4013.             try{
  4014.                 boolean debug = propertiesReader.isFileSystemRecoveryDebug();
  4015.                 
  4016.                 Logger logRecoveryFS = OpenSPCoop2Logger.getLoggerOpenSPCoopFileSystemRecovery(debug);
  4017.                             
  4018.                 if(propertiesReader.isFileSystemRecoveryTimerEnabled()){
  4019.                     if(debug)
  4020.                         logRecoveryFS.debug("Avvio inizializzazione thread per recovery da file system ...");
  4021.                     OpenSPCoop2Startup.this.threadFileSystemRecovery = new TimerFileSystemRecoveryThread(logRecoveryFS,
  4022.                             OpenSPCoop2Logger.getLoggerOpenSPCoopFileSystemRecoverySql(debug));
  4023.                     OpenSPCoop2Startup.this.threadFileSystemRecovery.start();
  4024.                     forceLogRecoveryFileSystem.info("Thread per la gestione transazioni stateful avviato correttamente");
  4025.                     TimerFileSystemRecoveryThread.setSTATE( TimerState.ENABLED );
  4026.                 }
  4027.                 else{
  4028.                     forceLogRecoveryFileSystem.info("Thread per il recovery da file system disabilitato");
  4029.                 }
  4030.             
  4031.             }catch(Exception e){
  4032.                 String msgError = "Inizializzazione thread per il recovery da file system non riuscita: "+e.getMessage();
  4033.                 forceLogRecoveryFileSystem.error(msgError,e);
  4034.                 msgDiag.logStartupError(e,"Inizializzazione Recovery da FileSystem");
  4035.                 return;
  4036.             }
  4037.             
  4038.             
  4039.             
  4040.     
  4041.             
  4042.             /* ------------ Eventi (ed in oltre avvia il thread) ------------ */
  4043.             Logger forceLogEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(true);
  4044.             try{
  4045.                 if(propertiesReader.isEventiEnabled()){
  4046.                     OpenSPCoop2Startup.this.gestoreEventi = GestoreEventi.getInstance();
  4047.                     boolean debugEventi = propertiesReader.isEventiDebug();
  4048.                     Logger logEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(debugEventi);
  4049.                     
  4050.                     if(propertiesReader.isEventiRegistrazioneStatoPorta()){
  4051.                         Evento evento = new Evento();
  4052.                         evento.setTipo(TipoEvento.STATO_GATEWAY.getValue());
  4053.                         evento.setCodice(CodiceEventoStatoGateway.START.getValue());
  4054.                         evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  4055.                         evento.setClusterId(clusterID);
  4056.                         OpenSPCoop2Startup.this.gestoreEventi.log(evento);
  4057.                     }
  4058.                     
  4059.                     // Timer
  4060.                     if(propertiesReader.isEventiTimerEnabled()){
  4061.                         try{
  4062.                             if(debugEventi)
  4063.                                 logEventi.debug("Avvio inizializzazione thread per Eventi ...");
  4064.                             OpenSPCoop2Startup.this.threadEventi = new TimerEventiThread(logEventi);
  4065.                             OpenSPCoop2Startup.this.threadEventi.start();
  4066.                             TimerEventiThread.setSTATE( TimerState.ENABLED );
  4067.                             forceLogEventi.info("Thread per gli Eventi avviato correttamente");
  4068.                         }catch(Exception e){
  4069.                             throw new HandlerException("Avvio timer degli eventi fallito: "+e.getMessage(),e);
  4070.                         }
  4071.                     }
  4072.                     else{
  4073.                         forceLogEventi.info("Thread per gli Eventi disabilitato");
  4074.                     }
  4075.                 }
  4076.             }catch(Exception e){
  4077.                 String msgError = "Inizializzazione gestore eventi: "+e.getMessage();
  4078.                 forceLogEventi.error(msgError,e);
  4079.                 msgDiag.logStartupError(e,"Inizializzazione GestoreEventi");
  4080.                 return;
  4081.             }
  4082.             
  4083.             /* ------------ Evento start per ControlloTraffico ------------ */
  4084.             try{
  4085.                 if(propertiesReader.isControlloTrafficoEnabled() && propertiesReader.isAllarmiEnabled()) {
  4086.                     
  4087.                     ConfigurazioneGatewayControlloTraffico config = propertiesReader.getConfigurazioneControlloTraffico();
  4088.                     if(config.isNotifierEnabled()) {
  4089.                     
  4090.                         INotify notifier = config.getNotifier();
  4091.                         if(notifier.isNotifichePassiveAttive()) {
  4092.                             
  4093.                             boolean debug = propertiesReader.isAllarmiDebug();
  4094.                             notifier.notificaGatewayRiavviato(OpenSPCoop2Logger.getLoggerOpenSPCoopAllarmi(debug), debug);
  4095.                             
  4096.                         }
  4097.                     }
  4098.                 }
  4099.             }catch(Exception e){
  4100.                 String msgError = "Segnalazione gateway ripartito al controllo del traffico non riuscita: "+e.getMessage();
  4101.                 forceLogEventi.error(msgError,e);
  4102.                 msgDiag.logStartupError(e,"Segnalazione GovWayStarted ControlloTraffico");
  4103.                 return;
  4104.             }
  4105.                     
  4106.             
  4107.             
  4108.             
  4109.             
  4110.             
  4111.             /*----------- Inizializzazione Thread per Configurazione Cluster Dinamica --------------*/
  4112.             try{
  4113.                 boolean rateLimitingGestioneCluster = false;
  4114.                 if(propertiesReader.isControlloTrafficoEnabled()) {
  4115.                     rateLimitingGestioneCluster = GestorePolicyAttive.isAttivo(PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES);
  4116.                 }
  4117.                 if(propertiesReader.isClusterDinamico() || rateLimitingGestioneCluster) {   
  4118.                     startTimerClusterDinamicoThread();
  4119.                 }
  4120.             }catch(Exception e){
  4121.                 this.logError("Riscontrato errore durante l'inizializzazione del thread che aggiorna il cluster dinamico: "+e.getMessage(),e);
  4122.                 return;
  4123.             }
  4124.             
  4125.             
  4126.             
  4127.             
  4128.             /*----------- Buffer UUID --------------*/
  4129.             try{
  4130.                 if(UniqueIdentifierManager.isBufferSupported() && propertiesReader.getIDManagerBufferSize()>0) {
  4131.                     UniversallyUniqueIdentifierProducer.initialize(propertiesReader.getIDManagerBufferSize(), OpenSPCoop2Logger.getLoggerOpenSPCoopTimers());
  4132.                     OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer = UniversallyUniqueIdentifierProducer.getInstance();
  4133.                     OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer.start();
  4134.                     OpenSPCoop2Startup.logStartupInfo("Thread per la produzione di un buffer di uuid avviato correttamente");
  4135.                 }
  4136.             }catch(Exception e){
  4137.                 this.logError("Riscontrato errore durante l'inizializzazione del thread che produce e mantiene in un buffer gli uuid: "+e.getMessage(),e);
  4138.                 return;
  4139.             }
  4140.             
  4141.             
  4142.             
  4143.             
  4144.             /* ----------- Inizializzazione Cache Cleaner ------------ */
  4145.             try{
  4146.                 GestoreCacheCleaner.initialize();
  4147.             }catch(Exception e){
  4148.                 this.logError("Riscontrato errore durante l'inizializzazione del ripulitore delle cache: "+e.getMessage(),e);
  4149.                 return;
  4150.             }
  4151.             
  4152.             
  4153.             
  4154.             

  4156.             /* ------------ Jminix StandaloneMiniConsole  ------------ */
  4157.             if(propertiesReader.getPortJminixConsole()!=null){
  4158.                 try{
  4159.                     jminixStandaloneConsole = new StandaloneMiniConsole(propertiesReader.getPortJminixConsole());
  4160.                     log.info("JminixStandaloneConsole correttamente avviata");
  4161.                     logCore.info("JminixStandaloneConsole correttamente avviata");
  4162.                 }catch(Throwable e){
  4163.                     logCore.error("Errore durante l'avvio della jminixStandaloneConsole: "+e.getMessage(),e);
  4164.                     msgDiag.logStartupError(e,"Inizializzazione JminixStandaloneConsole");
  4165.                 }
  4166.             }
  4167.             
  4168.             
  4169.             




  4174.             /* ------------ OpenSPCoop startup terminato  ------------ */
  4175.             long endDate = System.currentTimeMillis();
  4176.             long secondStarter = (endDate - OpenSPCoop2Startup.this.startDate) / 1000;
  4177.             msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_OPENSPCOOP_STARTUP);
  4178.             msgDiag.addKeyword(CostantiPdD.KEY_VERSIONE_PORTA, propertiesReader.getPddDetailsForLog());
  4179.             msgDiag.addKeyword(CostantiPdD.KEY_TEMPO_AVVIO, secondStarter+" secondi");
  4180.             OpenSPCoop2Startup.logStartupInfo(propertiesReader.getPddDetailsForLog()+" avviata correttamente in "+secondStarter+" secondi.");
  4181.             if(OpenSPCoop2Logger.isLoggerOpenSPCoopConsoleStartupAgganciatoLog()){
  4182.                 // per farlo finire anche sul server.log
  4183.                 System.out.println(propertiesReader.getPddDetailsForLog()+" avviata correttamente in "+secondStarter+" secondi.");
  4184.             }
  4185.             msgDiag.logPersonalizzato("pdd");
  4186.             MsgDiagnostico msgIM = MsgDiagnostico.newInstance(IntegrationManager.ID_MODULO);
  4187.             msgIM.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_OPENSPCOOP_STARTUP);
  4188.             msgIM.addKeyword(CostantiPdD.KEY_VERSIONE_PORTA, propertiesReader.getPddDetailsForLog());
  4189.             msgIM.addKeyword(CostantiPdD.KEY_TEMPO_AVVIO, secondStarter+" secondi");
  4190.             msgIM.logPersonalizzato("IntegrationManager");
  4191.             

  4193.         }

  4195.     }
  4196.     
  4197.     private static void setSystemProperties(String propName, String propValue) {
  4198.         System.setProperty(propName, propValue);
  4199.         OpenSPCoop2Startup.logStartupInfo("Hazelcast - '"+propName+"': "+System.getProperty(propName));
  4200.     }
  4201.     
  4202.     public static void startTimerClusterDinamicoThread() throws Exception {
  4203.         if(OpenSPCoop2Startup.threadClusterDinamico == null) {
  4204.             initTimerClusterDinamicoThread();
  4205.         }
  4206.     }
  4207.     private static synchronized void initTimerClusterDinamicoThread() throws Exception {
  4208.         if(OpenSPCoop2Startup.threadClusterDinamico == null) {
  4209.             Logger forceLogEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(true);
  4210.             OpenSPCoop2Startup.threadClusterDinamico = new TimerClusterDinamicoThread(OpenSPCoop2Logger.getLoggerOpenSPCoopTimers());
  4211.             OpenSPCoop2Startup.threadClusterDinamico.start();
  4212.             TimerClusterDinamicoThread.setSTATE( TimerState.ENABLED );
  4213.             forceLogEventi.info("Thread per l'aggiornamento del cluster avviato correttamente");
  4214.         }
  4215.     }
  4216.     
  4217.     public static boolean isStartedTimerClusteredRateLimitingLocalCache() {
  4218.         return OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache!=null;
  4219.     }
  4220.     public static void startTimerClusteredRateLimitingLocalCache(GestorePolicyAttiveInMemory gestore) throws Exception {
  4221.         if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache == null) {
  4222.             initTimerClusteredRateLimitingLocalCache(gestore);
  4223.         }
  4224.     }
  4225.     private static synchronized void initTimerClusteredRateLimitingLocalCache(GestorePolicyAttiveInMemory gestore) throws Exception {
  4226.         if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache == null) {
  4227.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  4228.             Logger logControlloTraffico = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(true);//properties.isControlloTrafficoDebug());
  4229.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache = new TimerClusteredRateLimitingLocalCache(OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), gestore);
  4230.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.setTimeout(properties.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate());
  4231.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.start();
  4232.             logControlloTraffico.info("Thread per l'aggiornamento della LocalCache tramite Hazelcast avviato correttamente");
  4233.         }
  4234.     }
  4235.     
  4236.     
  4237.     /**
  4238.      * Undeploy dell'applicazione WEB di OpenSPCoop
  4239.      *
  4240.      * @param sce Servlet Context Event
  4241.      * 
  4242.      */
  4243.     @Override
  4244.     public void contextDestroyed(ServletContextEvent sce) {

  4246.         OpenSPCoop2Startup.setContextDestroyed(true);
  4247.         
  4248.         OpenSPCoop2Properties properties = null;
  4249.         try {
  4250.             properties = OpenSPCoop2Properties.getInstance();
  4251.         }catch(Throwable e){
  4252.             // ignore
  4253.         }
  4254.         
  4255.         // ID Cluster
  4256.         try{
  4257.             if(OpenSPCoop2Startup.threadClusterDinamico!=null){
  4258.                 OpenSPCoop2Startup.threadClusterDinamico.setStop(true);
  4259.             }
  4260.         }catch(Throwable e){
  4261.             // ignore
  4262.         }
  4263.         try{
  4264.             boolean rateLimitingGestioneCluster = false;
  4265.             if(properties!=null && properties.isControlloTrafficoEnabled()) {
  4266.                 rateLimitingGestioneCluster = GestorePolicyAttive.isAttivo(PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES);
  4267.             }
  4268.             if( (properties!=null && properties.isClusterDinamico()) || rateLimitingGestioneCluster) {  
  4269.                 DynamicClusterManager.getInstance().unregister(OpenSPCoop2Startup.log);
  4270.             }
  4271.         }catch(Throwable e){
  4272.             // ignore
  4273.         }
  4274.         
  4275.         
  4276.         // Eventi
  4277.         try{
  4278.             if(properties!=null) {
  4279.                 String clusterID = properties.getClusterId(false);
  4280.                 boolean debugEventi = properties.isEventiDebug();
  4281.                 Logger logEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(debugEventi);
  4282.                 Evento eventoShutdown = null;
  4283.                 try{
  4284.                     if(OpenSPCoop2Startup.this.gestoreEventi!=null){
  4285.                         if(properties.isEventiRegistrazioneStatoPorta()){
  4286.                             eventoShutdown = new Evento();
  4287.                             eventoShutdown.setTipo(TipoEvento.STATO_GATEWAY.getValue());
  4288.                             eventoShutdown.setCodice(CodiceEventoStatoGateway.STOP.getValue());
  4289.                             eventoShutdown.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  4290.                             eventoShutdown.setClusterId(clusterID);
  4291.                             OpenSPCoop2Startup.this.gestoreEventi.log(eventoShutdown,true);
  4292.                         }
  4293.                     }
  4294.                 }catch(Exception e){
  4295.                     // L'errore puo' avvenire poiche' lo shutdown puo' anche disattivare il datasource
  4296.                     logEventi.debug("Errore durante la segnalazione di shutdown ('Emissione Evento'): "+e.getMessage(),e);
  4297.                     if(eventoShutdown!=null){
  4298.                         try{
  4299.                             if(eventoShutdown.getOraRegistrazione()==null){
  4300.                                 eventoShutdown.setOraRegistrazione(DateManager.getDate());
  4301.                             }
  4302.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  4303.                             eventoShutdown.writeTo(bout, WriteToSerializerType.XML_JAXB);
  4304.                             bout.flush();
  4305.                             bout.close();
  4306.                             FileSystemSerializer.getInstance().registraEvento(bout.toByteArray(), eventoShutdown.getOraRegistrazione());
  4307.                         }catch(Exception eSerializer){
  4308.                             logEventi.error("Errore durante la registrazione su file system dell'evento: "+eSerializer.getMessage(),eSerializer);
  4309.                         }
  4310.                     }
  4311.                 }
  4312.     
  4313.                 if(properties.isEventiTimerEnabled()){
  4314.                     try{    
  4315.                         if(debugEventi)
  4316.                             logEventi.debug("Recupero thread per gli Eventi ...");
  4317.                         if(OpenSPCoop2Startup.this.threadEventi!=null){
  4318.                             OpenSPCoop2Startup.this.threadEventi.setStop(true);
  4319.                             if(debugEventi)
  4320.                                 logEventi.debug("Richiesto stop al thread per gli Eventi");
  4321.                         }else{
  4322.                             throw new CoreException("Thread per gli Eventi non trovato");
  4323.                         }
  4324.                     }catch(Exception e){
  4325.                         if(logEventi!=null){
  4326.                             if(debugEventi)
  4327.                                 logEventi.error("Errore durante la gestione dell'exit (ThreadEventi): "+e.getMessage(),e);
  4328.                         }
  4329.                     }
  4330.                 }
  4331.             }
  4332.         }catch(Throwable e){
  4333.             // ignore
  4334.         }
  4335.         
  4336.         // Recovery FileSystem
  4337.         try {
  4338.             if(properties!=null && properties.isFileSystemRecoveryTimerEnabled()){
  4339.                 boolean debugRecoveryFileSystem = properties.isFileSystemRecoveryDebug();
  4340.                 Logger logRecoveryFileSystem = OpenSPCoop2Logger.getLoggerOpenSPCoopFileSystemRecovery(debugRecoveryFileSystem);
  4341.                 if(debugRecoveryFileSystem)
  4342.                     logRecoveryFileSystem.debug("Recupero thread per il recovery da file system ...");
  4343.                 if(OpenSPCoop2Startup.this.threadFileSystemRecovery!=null){
  4344.                     OpenSPCoop2Startup.this.threadFileSystemRecovery.setStop(true);
  4345.                     if(debugRecoveryFileSystem)
  4346.                         logRecoveryFileSystem.debug("Richiesto stop al thread per il recovery da file system");
  4347.                 }else{
  4348.                     throw new CoreException("Thread per il recovery da file system non trovato");
  4349.                 }   
  4350.             }
  4351.         }catch(Throwable e){
  4352.             // ignore
  4353.         }
  4354.         
  4355.         // GestoreTransazioniStateful
  4356.         try {
  4357.             if(properties!=null && properties.isTransazioniStatefulEnabled()){
  4358.                 boolean debugTransazioniStateful = properties.isTransazioniStatefulDebug();
  4359.                 Logger logTransazioniStateful = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniStateful(debugTransazioniStateful);
  4360.                 if(debugTransazioniStateful)
  4361.                     logTransazioniStateful.debug("Recupero thread per la gestione delle transazioni stateful ...");
  4362.                 if(OpenSPCoop2Startup.this.threadRepositoryStateful!=null){
  4363.                     OpenSPCoop2Startup.this.threadRepositoryStateful.setStop(true);
  4364.                     if(debugTransazioniStateful)
  4365.                         logTransazioniStateful.debug("Richiesto stop al thread per la gestione delle transazioni stateful");
  4366.                 }else{
  4367.                     throw new CoreException("Thread per la gestione delle transazioni stateful non trovato");
  4368.                 }   
  4369.             }
  4370.         }catch(Throwable e){
  4371.             // ignore
  4372.         }

  4374.         // Statistiche
  4375.         try{
  4376.             if(properties!=null && properties.isStatisticheGenerazioneEnabled()){
  4377.                 boolean debugStatistiche = properties.isStatisticheGenerazioneDebug();
  4378.                 
  4379.                 Logger logStatisticheOrarie = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_ORARIE, debugStatistiche);
  4380.                 if(debugStatistiche)
  4381.                     logStatisticheOrarie.debug("Recupero thread per la generazione delle statistiche orarie ...");
  4382.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie!=null){
  4383.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie.setStop(true);
  4384.                     if(debugStatistiche)
  4385.                         logStatisticheOrarie.debug("Richiesto stop al thread per la generazione delle statistiche orarie");
  4386.                 }else{
  4387.                     if(properties.isStatisticheGenerazioneBaseOrariaEnabled()) {
  4388.                         throw new CoreException("Thread per la generazione delle statistiche orarie non trovato");
  4389.                     }
  4390.                 }   
  4391.                 
  4392.                 Logger logStatisticheGiornaliere = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_GIORNALIERE, debugStatistiche);
  4393.                 if(debugStatistiche)
  4394.                     logStatisticheGiornaliere.debug("Recupero thread per la generazione delle statistiche giornaliere ...");
  4395.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere!=null){
  4396.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere.setStop(true);
  4397.                     if(debugStatistiche)
  4398.                         logStatisticheGiornaliere.debug("Richiesto stop al thread per la generazione delle statistiche giornaliere");
  4399.                 }else{
  4400.                     if(properties.isStatisticheGenerazioneBaseGiornalieraEnabled()) {
  4401.                         throw new CoreException("Thread per la generazione delle statistiche giornaliere non trovato");
  4402.                     }
  4403.                 }
  4404.                 
  4405.                 Logger logStatisticheSettimanali = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_SETTIMANALI, debugStatistiche);
  4406.                 if(debugStatistiche)
  4407.                     logStatisticheSettimanali.debug("Recupero thread per la generazione delle statistiche settimanali ...");
  4408.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali!=null){
  4409.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali.setStop(true);
  4410.                     if(debugStatistiche)
  4411.                         logStatisticheSettimanali.debug("Richiesto stop al thread per la generazione delle statistiche settimanali");
  4412.                 }else{
  4413.                     if(properties.isStatisticheGenerazioneBaseSettimanaleEnabled()) {
  4414.                         throw new CoreException("Thread per la generazione delle statistiche settimanali non trovato");
  4415.                     }
  4416.                 }
  4417.                 
  4418.                 Logger logStatisticheMensili = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_MENSILI, debugStatistiche);
  4419.                 if(debugStatistiche)
  4420.                     logStatisticheMensili.debug("Recupero thread per la generazione delle statistiche mensili ...");
  4421.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili!=null){
  4422.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili.setStop(true);
  4423.                     if(debugStatistiche)
  4424.                         logStatisticheMensili.debug("Richiesto stop al thread per la generazione delle statistiche mensili");
  4425.                 }else{
  4426.                     if(properties.isStatisticheGenerazioneBaseMensileEnabled()) {
  4427.                         throw new CoreException("Thread per la generazione delle statistiche mensili non trovato");
  4428.                     }
  4429.                 }
  4430.                 
  4431.                 Logger logPdndTracciamentoGenerazione = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.PDND_GENERAZIONE_TRACCIAMENTO, debugStatistiche);
  4432.                 if(debugStatistiche)
  4433.                     logPdndTracciamentoGenerazione.debug("Recupero thread per la generazione dei tracciamenti PDND ...");
  4434.                 if(OpenSPCoop2Startup.this.threadPdndTracciamentoGenerazione!=null){
  4435.                     OpenSPCoop2Startup.this.threadPdndTracciamentoGenerazione.setStop(true);
  4436.                     if(debugStatistiche)
  4437.                         logPdndTracciamentoGenerazione.debug("Richiesto stop al thread per la generazione dei tracciamenti PDND");
  4438.                 }else{
  4439.                     if(properties.isStatistichePdndTracciamentoGenerazioneEnabled()) {
  4440.                         throw new CoreException("Thread per la generazione dei tracciamenti PDND non trovato");
  4441.                     }
  4442.                 }
  4443.                 
  4444.                 Logger logPdndTracciamentoPubblicazione = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.PDND_PUBBLICAZIONE_TRACCIAMENTO, debugStatistiche);
  4445.                 if(debugStatistiche)
  4446.                     logPdndTracciamentoPubblicazione.debug("Recupero thread per la pubblicazione dei tracciamenti PDND ...");
  4447.                 if(OpenSPCoop2Startup.this.threadPdndTracciamentoPubblicazione!=null){
  4448.                     OpenSPCoop2Startup.this.threadPdndTracciamentoPubblicazione.setStop(true);
  4449.                     if(debugStatistiche)
  4450.                         logPdndTracciamentoPubblicazione.debug("Richiesto stop al thread per la pubblicazione dei tracciamenti PDND");
  4451.                 }else{
  4452.                     if(properties.isStatistichePdndTracciamentoPubblicazioneEnabled()) {
  4453.                         throw new CoreException("Thread per la pubblicazione dei tracciamenti PDND non trovato");
  4454.                     }
  4455.                 }
  4456.                 
  4457.             }
  4458.         }catch (Throwable e) {
  4459.             // ignore
  4460.         }
  4461.         
  4462.         // Timer per la gestione delle chiavi da PDND 
  4463.         
  4464.         try{
  4465.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreChiaviPDNDEnabled){
  4466.                 boolean debug = properties.isGestoreChiaviPDNDDebug();
  4467.             
  4468.                 Logger logGestorePDND = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreChiaviPDND(debug);
  4469.                 if(debug)
  4470.                     logGestorePDND.debug("Recupero thread per la gestione delle chiavi PDND ...");
  4471.                 if(OpenSPCoop2Startup.this.threadGestoreChiaviPDND!=null){
  4472.                     OpenSPCoop2Startup.this.threadGestoreChiaviPDND.setStop(true);
  4473.                     if(debug)
  4474.                         logGestorePDND.debug("Richiesto stop al thread per la gestione delle chiavi PDND");
  4475.                 }else{
  4476.                     throw new CoreException("Thread per la gestione delle chiavi PDND non trovato");
  4477.                 }   
  4478.             }
  4479.         }catch (Throwable e) {
  4480.             // ignore
  4481.         }
  4482.         try{
  4483.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreChiaviPDNDEnabled){
  4484.                 boolean debug = properties.isGestoreChiaviPDNDDebug();
  4485.             
  4486.                 Logger logGestorePDND = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreChiaviPDND(debug);
  4487.                 if(debug)
  4488.                     logGestorePDND.debug("Recupero thread per la gestione della cache delle chiavi PDND ...");
  4489.                 if(OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND!=null){
  4490.                     OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND.setStop(true);
  4491.                     if(debug)
  4492.                         logGestorePDND.debug("Richiesto stop al thread per la gestione della cache delle chiavi PDND");
  4493.                 }else{
  4494.                     throw new CoreException("Thread per gestione della cache delle chiavi PDND non trovato");
  4495.                 }   
  4496.             }
  4497.         }catch (Throwable e) {
  4498.             // ignore
  4499.         }
  4500.         
  4501.         // Timer per la gestione delle operazioni remote in un cluster dinamico
  4502.         
  4503.         try{
  4504.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreOperazioniRemoteEnabled){
  4505.                 boolean debug = properties.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
  4506.             
  4507.                 Logger logGestoreOperazioniRemote = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreOperazioniRemote(debug);
  4508.                 if(debug)
  4509.                     logGestoreOperazioniRemote.debug("Recupero thread per la gestione delle operazioni remote ...");
  4510.                 if(OpenSPCoop2Startup.this.threadGestoreOperazioniRemote!=null){
  4511.                     OpenSPCoop2Startup.this.threadGestoreOperazioniRemote.setStop(true);
  4512.                     if(debug)
  4513.                         logGestoreOperazioniRemote.debug("Richiesto stop al thread per la gestione delle operazioni remote");
  4514.                 }else{
  4515.                     throw new CoreException("Thread per la gestione delle operazioni remote non trovato");
  4516.                 }   
  4517.             }
  4518.         }catch (Throwable e) {
  4519.             // ignore
  4520.         }
  4521.         try{
  4522.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreOperazioniRemoteEnabled){
  4523.                 boolean debug = properties.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
  4524.             
  4525.                 Logger logGestoreOperazioniRemote = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreOperazioniRemote(debug);
  4526.                 if(debug)
  4527.                     logGestoreOperazioniRemote.debug("Recupero thread per lo svecchiamento delle operazioni remote ...");
  4528.                 if(OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote!=null){
  4529.                     OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote.setStop(true);
  4530.                     if(debug)
  4531.                         logGestoreOperazioniRemote.debug("Richiesto stop al thread per lo svecchiamento delle operazioni remote");
  4532.                 }else{
  4533.                     throw new CoreException("Thread per lo svecchiamento delle operazioni remote non trovato");
  4534.                 }   
  4535.             }
  4536.         }catch (Throwable e) {
  4537.             // ignore
  4538.         }
  4539.         
  4540.         // ExitHandler
  4541.         try{
  4542.             ExitContext context = new ExitContext();
  4543.             context.setPddContext(this.pddContext);
  4544.             context.setLogConsole(OpenSPCoop2Startup.log);
  4545.             context.setLogCore(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  4546.             GestoreHandlers.exit(context);
  4547.         }catch(Throwable e){
  4548.             // ignore
  4549.         }
  4550.         
  4551.         // Gestione Stato ControlloTraffico
  4552.         if(properties!=null && properties.isControlloTrafficoEnabled()){
  4553.             OutputStream out = null;
  4554.             Logger logControlloTraffico = null;
  4555.             List<PolicyGroupByActiveThreadsType> tipiGestorePolicyRateLimiting = null;
  4556.             try{
  4557.                 logControlloTraffico = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(properties.isControlloTrafficoDebug());
  4558.                 tipiGestorePolicyRateLimiting = GestorePolicyAttive.getTipiGestoriAttivi();
  4559.             }catch(Throwable e){
  4560.                 if(logControlloTraffico!=null){
  4561.                     logControlloTraffico.error("Errore durante la terminazione dei gestori delle policy di Rate Limiting: "+e.getMessage(),e);
  4562.                 }
  4563.             }
  4564.             if(tipiGestorePolicyRateLimiting!=null && !tipiGestorePolicyRateLimiting.isEmpty()) {
  4565.                 for (PolicyGroupByActiveThreadsType type : tipiGestorePolicyRateLimiting) {
  4566.                     try{
  4567.                         File fRepository = properties.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  4568.                         if(fRepository!=null){
  4569.                             if(fRepository.exists()==false){
  4570.                                 throw new CoreException("Directory ["+fRepository.getAbsolutePath()+"] not exists");
  4571.                             }
  4572.                             if(fRepository.isDirectory()==false){
  4573.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] is not directory");
  4574.                             }
  4575.                             if(fRepository.canRead()==false){
  4576.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot read");
  4577.                             }
  4578.                             if(fRepository.canWrite()==false){
  4579.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot write");
  4580.                             }       
  4581.                             
  4582.                             File fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoImage(type));
  4583.                             out = new FileOutputStream(fDati, false); // se già esiste lo sovrascrive
  4584.                             GestorePolicyAttive.getInstance(type).serialize(out);
  4585.                             out.flush();
  4586.                             out.close();
  4587.                             out = null;
  4588.                             
  4589.                             boolean inizializzazioneAttiva = false;
  4590.                             // Il meccanismo di ripristino dell'immagine degli eventi non sembra funzionare
  4591.                             // Lascio comunque il codice se in futuro si desidera approfindire la questione
  4592.                             if(inizializzazioneAttiva) {
  4593.                                 fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoEventiImage(type));
  4594.                                 NotificatoreEventi.getInstance().serialize(fDati);
  4595.                             }
  4596.                             
  4597.                         }
  4598.                     }catch(Throwable e){
  4599.                         if(logControlloTraffico!=null){
  4600.                             logControlloTraffico.error("Errore durante la terminazione dei gestori delle policy di Rate Limiting: "+e.getMessage(),e);
  4601.                         }
  4602.                     }finally{
  4603.                         try{
  4604.                             if(out!=null){
  4605.                                 out.flush();
  4606.                             }
  4607.                         }catch(Exception eClose){
  4608.                             // ignore
  4609.                         }
  4610.                         try{
  4611.                             if(out!=null){
  4612.                                 out.close();
  4613.                             }
  4614.                         }catch(Exception eClose){
  4615.                             // ignore
  4616.                         }
  4617.                     }
  4618.                 }
  4619.             }
  4620.             
  4621.             if (OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache != null) {
  4622.                 OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.setStop(true);      
  4623.             }
  4624.         }
  4625.         
  4626.         // Fermo timer runtime
  4627.         if(this.serverJ2EE){
  4628.             try {
  4629.                 if(this.timerRiscontri!=null)
  4630.                     this.timerRiscontri.stop();
  4631.             } catch (Throwable e) {
  4632.                 // ignore
  4633.             }
  4634.             try {
  4635.                 if(this.timerEliminazioneMsg!=null)
  4636.                     this.timerEliminazioneMsg.stop();
  4637.             } catch (Throwable e) {
  4638.                 // ignore
  4639.             }
  4640.             try {
  4641.                 if(this.timerPuliziaMsgAnomali!=null)
  4642.                     this.timerPuliziaMsgAnomali.stop();
  4643.             } catch (Throwable e) {
  4644.                 // ignore
  4645.             }
  4646.             try {
  4647.                 if(this.timerRepositoryBuste!=null)
  4648.                     this.timerRepositoryBuste.stop();
  4649.             } catch (Throwable e) {
  4650.                 // ignore
  4651.             }
  4652.         }else{
  4653.             try{
  4654.                 if(this.threadEliminazioneMsg!=null) {
  4655.                     this.threadEliminazioneMsg.setStop(true);
  4656.                 }
  4657.             }catch (Throwable e) {
  4658.                 // ignore
  4659.             }
  4660.             try{
  4661.                 if(this.threadPuliziaMsgAnomali!=null)
  4662.                     this.threadPuliziaMsgAnomali.setStop(true);
  4663.             }catch (Throwable e) {
  4664.                 // ignore
  4665.             }
  4666.             try{
  4667.                 if(this.threadRepositoryBuste!=null)
  4668.                     this.threadRepositoryBuste.setStop(true);
  4669.             }catch (Throwable e) {
  4670.                 // ignore
  4671.             }
  4672.         }
  4673.         try{
  4674.             if(this.threadConsegnaContenutiApplicativiMap!=null && !this.threadConsegnaContenutiApplicativiMap.isEmpty()) {
  4675.                 for (String coda : this.threadConsegnaContenutiApplicativiMap.keySet()) {
  4676.                     TimerConsegnaContenutiApplicativiThread timer = this.threadConsegnaContenutiApplicativiMap.get(coda);
  4677.                     timer.setStop(true);
  4678.                 }
  4679.             }
  4680.         }catch (Throwable e) {
  4681.             // ignore
  4682.         }

  4684.         // fermo timer Monitoraggio Risorse
  4685.         try{
  4686.             if(this.timerMonitoraggioRisorse!=null)
  4687.                 this.timerMonitoraggioRisorse.setStop(true);
  4688.         }catch (Throwable e) {
  4689.             // ignore
  4690.         }

  4692.         // fermo timer Threshold
  4693.         try{
  4694.             if(this.timerThreshold!=null)
  4695.                 this.timerThreshold.setStop(true);
  4696.         }catch (Throwable e) {
  4697.             // ignore
  4698.         }

  4700.         // Rilascio risorse JMX
  4701.         if(this.gestoreRisorseJMX!=null){
  4702.             this.gestoreRisorseJMX.unregisterMBeans();
  4703.         }

  4705.         // Verifico che i timer siano conclusi prima di rilasciare i lock
  4706.         try{
  4707.             if(this.threadEventi!=null)
  4708.                 this.threadEventi.waitShutdown();
  4709.         }catch (Throwable e) {
  4710.             // ignore
  4711.         }
  4712.         try{
  4713.             if(this.threadFileSystemRecovery!=null)
  4714.                 this.threadFileSystemRecovery.waitShutdown();
  4715.         }catch (Throwable e) {
  4716.             // ignore
  4717.         }
  4718.         try{
  4719.             if(this.threadRepositoryStateful!=null)
  4720.                 this.threadRepositoryStateful.waitShutdown();
  4721.         }catch (Throwable e) {
  4722.             // ignore
  4723.         }
  4724.         try{
  4725.             if(this.threadGenerazioneStatisticheOrarie!=null)
  4726.                 this.threadGenerazioneStatisticheOrarie.waitShutdown();
  4727.         }catch (Throwable e) {
  4728.             // ignore
  4729.         }
  4730.         try{
  4731.             if(this.threadGenerazioneStatisticheGiornaliere!=null)
  4732.                 this.threadGenerazioneStatisticheGiornaliere.waitShutdown();
  4733.         }catch (Throwable e) {
  4734.             // ignore
  4735.         }
  4736.         try{
  4737.             if(this.threadGenerazioneStatisticheSettimanali!=null)
  4738.                 this.threadGenerazioneStatisticheSettimanali.waitShutdown();
  4739.         }catch (Throwable e) {
  4740.             // ignore
  4741.         }
  4742.         try{
  4743.             if(this.threadGenerazioneStatisticheMensili!=null)
  4744.                 this.threadGenerazioneStatisticheMensili.waitShutdown();
  4745.         }catch (Throwable e) {
  4746.             // ignore
  4747.         }
  4748.         if(this.serverJ2EE){ // TODO ATTESA ATTIVA CHE SI FERMINO PER J2EE
  4749.             Utilities.sleep(5000); // aspetto che i timer terminano la loro gestione.
  4750.         }
  4751.         else {
  4752.             try{
  4753.                 if(this.threadEliminazioneMsg!=null) {
  4754.                     this.threadEliminazioneMsg.waitShutdown();
  4755.                 }
  4756.             }catch (Throwable e) {
  4757.                 // ignore
  4758.             }
  4759.             try{
  4760.                 if(this.threadPuliziaMsgAnomali!=null) {
  4761.                     this.threadPuliziaMsgAnomali.waitShutdown();
  4762.                 }
  4763.             }catch (Throwable e) {
  4764.                 // ignore
  4765.             }
  4766.             try{
  4767.                 if(this.threadRepositoryBuste!=null) {
  4768.                     this.threadRepositoryBuste.waitShutdown();
  4769.                 }
  4770.             }catch (Throwable e) {
  4771.                 // ignore
  4772.             }
  4773.         }
  4774.         try{
  4775.             if(this.threadConsegnaContenutiApplicativiMap!=null && !this.threadConsegnaContenutiApplicativiMap.isEmpty()) {
  4776.                 for (String coda : this.threadConsegnaContenutiApplicativiMap.keySet()) {
  4777.                     TimerConsegnaContenutiApplicativiThread timer = this.threadConsegnaContenutiApplicativiMap.get(coda);
  4778.                     timer.waitShutdown();
  4779.                 }
  4780.             }
  4781.         }catch (Throwable e) {
  4782.             // ignore
  4783.         }
  4784.         try{
  4785.             if(this.timerMonitoraggioRisorse!=null) {
  4786.                 this.timerMonitoraggioRisorse.waitShutdown();
  4787.             }
  4788.         }catch (Throwable e) {
  4789.             // ignore
  4790.         }
  4791.         try{
  4792.             if(this.timerThreshold!=null) {
  4793.                 this.timerThreshold.waitShutdown();
  4794.             }
  4795.         }catch (Throwable e) {
  4796.             // ignore
  4797.         }
  4798.         try{
  4799.             if(OpenSPCoop2Startup.threadClusterDinamico!=null)
  4800.                 OpenSPCoop2Startup.threadClusterDinamico.waitShutdown();
  4801.         }catch (Throwable e) {
  4802.             // ignore
  4803.         }
  4804.         try{
  4805.             if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache!=null)
  4806.                 OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.waitShutdown();
  4807.         }catch (Throwable e) {
  4808.             // ignore
  4809.         }
  4810.         
  4811.         // Rilascio lock (da fare dopo che i timer sono stati fermati)
  4812.         // L'errore puo' avvenire poiche' lo shutdown puo' anche disattivare il datasource
  4813.         boolean logErrorConnection = false;
  4814.         TimerUtils.relaseLockTimers(properties, ID_MODULO, OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), logErrorConnection);
  4815.         
  4816.         // UniversallyUniqueIdentifierProducer (fermo dopo lo stop di tutte le altre attivita)
  4817.         try{
  4818.             if(OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer!=null){
  4819.                 OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer.setStop(true);
  4820.                 OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer.waitShutdown();
  4821.             }
  4822.         }catch(Throwable e){
  4823.             // ignore
  4824.         }
  4825.         
  4826.         // DataManger
  4827.         DateManager.close();

  4829.         // Jminix StandaloneMiniConsole
  4830.         try{
  4831.             if(jminixStandaloneConsole!=null){
  4832.                 jminixStandaloneConsole.shutdown();
  4833.             }
  4834.         }catch (Throwable e) {
  4835.             // ignore
  4836.         }

  4838.         // *** Repository plugins ***
  4839.         try{
  4840.             CorePluginLoader.close(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  4841.         }catch(Throwable e){
  4842.             // ignore
  4843.         }
  4844.         
  4845.         // *** Hazelcast ***
  4846.         if(properties!=null && properties.isControlloTrafficoEnabled()){
  4847.             HazelcastManager.close();
  4848.         }
  4849.         
  4850.         // *** Semaphore **
  4851.         try{
  4852.             org.openspcoop2.utils.SemaphoreLock.releaseScheduledExecutorService();
  4853.         }catch(Throwable e){
  4854.             // ignore
  4855.         }
  4856.         
  4857.         // Attendo qualche secondo
  4858.         Utilities.sleep(2000);
  4859.     }



  4863. }
Created with JaCoCo 0.8.8.202204050719