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

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



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

  270. public class OpenSPCoop2Startup implements ServletContextListener {

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

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

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

  291.     /** Context della Servlet */
  292.     ServletContext servletContext;

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

  300.     /** Timer per la gestione della funzionalita' 'RiscontriScaduti' */
  301.     private TimerGestoreBusteNonRiscontrate timerRiscontri;

  303.     /** Timer per l'eliminazione dei messaggi gestiti */
  304.     private TimerGestoreMessaggi timerEliminazioneMsg;
  305.     private TimerGestoreMessaggiThread threadEliminazioneMsg;

  307.     /** Timer per l'eliminazione dei messaggi anomali */
  308.     private TimerGestorePuliziaMessaggiAnomali timerPuliziaMsgAnomali;
  309.     private TimerGestorePuliziaMessaggiAnomaliThread threadPuliziaMsgAnomali;

  311.     /** Timer per l'eliminazione delle buste gestite */
  312.     private TimerGestoreRepositoryBuste timerRepositoryBuste;
  313.     private TimerGestoreRepositoryBusteThread threadRepositoryBuste;

  315.     /** Gestore Threshold */
  316.     private TimerThresholdThread timerThreshold = null;

  318.     /** Gestore Monitoraggio Risorse */
  319.     private TimerMonitoraggioRisorseThread timerMonitoraggioRisorse = null;

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

  368.     /** PdDContext */
  369.     private PdDContext pddContext = new PdDContext();
  370.     
  371.     /** OpenSPCoopStartupThread */
  372.     private OpenSPCoopStartupThread th;
  373.     
  374.     /** Jminix StandaloneMiniConsole */
  375.     private static StandaloneMiniConsole jminixStandaloneConsole;

  377.     /**
  378.      * Startup dell'applicazione WEB di OpenSPCoop
  379.      *
  380.      * @param sce Servlet Context Event
  381.      * 
  382.      */
  383.     @Override
  384.     public void contextInitialized(ServletContextEvent sce) {

  386.         OpenSPCoop2Startup.setContextDestroyed(false);
  387.         
  388.         this.startDate = System.currentTimeMillis();
  389.         
  390.         /* ------  Ottiene il servletContext --------*/
  391.         this.servletContext = sce.getServletContext();
  392.         this.th = new OpenSPCoopStartupThread();
  393.         new Thread(this.th).start();

  395.     }

  397.     class OpenSPCoopStartupThread implements Runnable {

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

  417.         public OpenSPCoopStartupThread() {                        
  418.         }

  420.         @Override
  421.         public void run() {

  423.             
  424.             
  425.             
  426.             /* ------------ LogConsole -------------------- */
  427.             // Inizializza lo startup log, utile per web spheare
  428.             if(!OpenSPCoop2Logger.initializeLogConsole(OpenSPCoop2Startup.log)){
  429.                 return;
  430.             }
  431.             OpenSPCoop2Startup.log = LoggerWrapperFactory.getLogger(LOG_CATEGORY_STARTUP);
  432.             
  433.             
  434.             
  435.             
  436.             


  439.             
  440.                     
  441.             
  442.             
  443.             
  444.             

  446.             /* ------------- Inizializzo ClassNameProperties di OpenSPCoop --------------- */
  447.             if( !ClassNameProperties.initialize(true)){
  448.                 this.logError("Riscontrato errore durante l'inizializzazione del reader di 'govway.classRegistry.properties'");
  449.                 return;
  450.             }
  451.             ClassNameProperties classNameReader = ClassNameProperties.getInstance();




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

  495.             
  496.             







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


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



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

  955.             org.openspcoop2.utils.Semaphore.setLogDebug(OpenSPCoop2Logger.getLoggerOpenSPCoopResources());
  956.             
  957.             


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










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





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

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

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





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





  1327.             /* -------------- Inizializzo DBManager --------------- */

  1329.             String erroreDB = null;
  1330.             try{
  1331.                 DBManager.initialize(propertiesReader.getJNDIName_DataSource(),
  1332.                         propertiesReader.getJNDIContext_DataSource());
  1333.             }catch(Exception e){
  1334.                 erroreDB = e.getMessage();
  1335.                 OpenSPCoop2Startup.logStartupInfo("Datasource non inizializzato... riprovo");
  1336.                 //msgDiag.logStartupError(e, "DatabaseManager");
  1337.                 logCore.error(erroreDB,e);
  1338.             }

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

  1352.                 if (DBManager.isInitialized()) {
  1353.                     trovato = true;
  1354.                 } else {
  1355.                     count += 10000;
  1356.                     Utilities.sleep(10000);
  1357.                 }
  1358.             }

  1360.             if (DBManager.isInitialized()) {
  1361.                 OpenSPCoop2Startup.logStartupInfo("Inizializzazione DBManager effettuata con successo.");
  1362.             } else {
  1363.                 OpenSPCoop2Startup.log.error("Inizializzazione DBManager non effettuata", new Exception(erroreDB));
  1364.                 //msgDiag.logStartupError(new Exception(erroreDB), "DatabaseManager");
  1365.                 return;
  1366.             }

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

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

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

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

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











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

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





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




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









  1687.             /* -------------- Inizializzo MsgDiagnostico -------------------- */
  1688.             MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(OpenSPCoop2Startup.ID_MODULO);


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

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

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

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

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

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

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

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

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


  2333.             /* ------------- Inizializzo il sistema di Logging per gli appender personalizzati --------------- */
  2334.             boolean isInitializeAppender = false;
  2335.             isInitializeAppender = OpenSPCoop2Logger.initializeMsgDiagnosticiOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderMessaggiDiagnostici());
  2336.             if(!isInitializeAppender){
  2337.                 return;
  2338.             }
  2339.             isInitializeAppender = OpenSPCoop2Logger.initializeTracciamentoOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderTracciamento());
  2340.             if(!isInitializeAppender){
  2341.                 return;
  2342.             }
  2343.             isInitializeAppender = OpenSPCoop2Logger.initializeDumpOpenSPCoopAppender(configurazionePdDManager.getOpenSPCoopAppenderDump());
  2344.             if(!isInitializeAppender){
  2345.                 return;
  2346.             }





  2352.             






  2359.             /* -------------- Inizializzo QueueManager --------------- */
  2360.             if(OpenSPCoop2Startup.this.serverJ2EE){
  2361.                 if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeReceiver()) 
  2362.                         || CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeSender()) ){

  2364.                     // Connection Factory
  2365.                     try{
  2366.                         QueueManager.initialize(propertiesReader.getJNDIName_ConnectionFactory(),
  2367.                                 propertiesReader.getJNDIContext_ConnectionFactory());
  2368.                     }catch(Exception e){
  2369.                         msgDiag.logStartupError(e, "QueueManager.initConnectionFactory");
  2370.                         return;
  2371.                     }
  2372.                     OpenSPCoop2Startup.logStartupInfo("Inizializzazione connectionFactoryJMS ["+propertiesReader.getJNDIName_ConnectionFactory()+"] effettuata.");

  2374.                     // Code di Ricezione
  2375.                     if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeReceiver()) 
  2376.                     ){
  2377.                         try{
  2378.                             QueueManager.initializeQueueNodeReceiver(propertiesReader.getJNDIContext_CodeInterne());
  2379.                         }catch(Exception e){
  2380.                             msgDiag.logStartupError(e, "QueueManager.initQueueNodeReceiver");
  2381.                             return;
  2382.                         }
  2383.                         OpenSPCoop2Startup.logStartupInfo("Inizializzazione code JMS per la ricezione di messaggi nell'infrastruttura di OpenSPCoop, effettuata.");
  2384.                     }

  2386.                     // Code di Spedizione
  2387.                     //if( CostantiConfigurazione.COMUNICAZIONE_INFRASTRUTTURALE_JMS.equals(propertiesReader.getNodeSender()) 
  2388.                     //){
  2389.                     try{
  2390.                         QueueManager.initializeQueueNodeSender(propertiesReader.getJNDIContext_CodeInterne());
  2391.                     }catch(Exception e){
  2392.                         msgDiag.logStartupError(e, "QueueManager.initQueueNodeSender");
  2393.                         return;
  2394.                     }
  2395.                     OpenSPCoop2Startup.logStartupInfo("Inizializzazione code JMS per la spedizione di messaggi nell'infrastruttura di OpenSPCoop, effettuata.");
  2396.                 }
  2397.             }


  2400.             
  2401.             






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

  2410.             // Check configurazione registro dei Servizi
  2411.             if( configurazionePdDManager.getAccessoRegistroServizi() == null ){
  2412.                 msgDiag.logStartupError("Riscontrato errore durante la lettura dei valori associati al registro dei servizi di OpenSPCoop.", "Lettura configurazione PdD");
  2413.                 return;
  2414.             }

  2416.             // Controllo la consistenza dei registri di tipo DB
  2417.             AccessoRegistro accessoRegistro = configurazionePdDManager.getAccessoRegistroServizi();
  2418.             for(int i=0; i<accessoRegistro.sizeRegistroList(); i++){    
  2419.                 AccessoRegistroRegistro registro = accessoRegistro.getRegistro(i);
  2420.                 if(CostantiConfigurazione.REGISTRO_DB.equals(registro.getTipo().toString())){
  2421.                     // Il tipo del DB e' obbligatorio.
  2422.                     // Controllo che vi sia o
  2423.                     // - come prefisso del datasource: tipoDatabase@datasource
  2424.                     // - come tipo di database della porta di dominio.
  2425.                     if(registro.getLocation().indexOf("@")!=-1){
  2426.                         // estrazione tipo database
  2427.                         try{
  2428.                             String tipoDatabase = DBUtils.estraiTipoDatabaseFromLocation(registro.getLocation());
  2429.                             String location = registro.getLocation().substring(registro.getLocation().indexOf("@")+1);
  2430.                             accessoRegistro.getRegistro(i).setLocation(location);
  2431.                             accessoRegistro.getRegistro(i).setTipoDatabase(tipoDatabase);
  2432.                         }catch(Exception e){
  2433.                             msgDiag.logStartupError(e, "Inizializzazione registro dei servizi di OpenSPCoop ["+registro.getNome()+"]; analisi del tipo di database (tipoDatabase@datasource)");
  2434.                             return;
  2435.                         }
  2436.                     }else{
  2437.                         if(propertiesReader.getDatabaseType()==null){
  2438.                             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",
  2439.                                     "Inizializzazione registro dei servizi di OpenSPCoop ["+registro.getNome()+"]; analisi del tipo di database");
  2440.                             return;
  2441.                         }else{
  2442.                             accessoRegistro.getRegistro(i).setTipoDatabase(propertiesReader.getDatabaseType());
  2443.                         }
  2444.                     }
  2445.                 }
  2446.             }

  2448.             // inizializzo registri
  2449.             DriverBYOK driverBYOK = null;
  2450.             try{
  2451.                 driverBYOK = DriverBYOKUtilities.newInstanceDriverBYOKRuntimeNode(logCore, false, true);
  2452.             }catch(Exception e){
  2453.                 msgDiag.logStartupError(e,"Inizializzazione driver BYOK fallita");
  2454.                 return;
  2455.             }
  2456.             boolean isInitializeRegistro = 
  2457.                 RegistroServiziReader.initialize(accessoRegistro,
  2458.                         logCore,OpenSPCoop2Startup.log,propertiesReader.isControlloRisorseRegistriRaggiungibilitaTotale(),
  2459.                         propertiesReader.isReadObjectStatoBozza(),propertiesReader.getJNDIName_DataSource(),
  2460.                         propertiesReader.isDSOp2UtilsEnabled(), propertiesReader.isRisorseJMXAbilitate(),
  2461.                         propertiesReader.isConfigurazioneCache_RegistryPrefill(), propertiesReader.getCryptConfigAutenticazioneSoggetti(),
  2462.                         propertiesReader.getCacheTypeRegistry(), driverBYOK);
  2463.             if(!isInitializeRegistro){
  2464.                 msgDiag.logStartupError("Inizializzazione fallita","Accesso registro/i dei servizi");
  2465.                 return;
  2466.             }
  2467.             if(propertiesReader.isConfigurazioneCache_RegistryPrefill() && propertiesReader.isConfigurazioneCache_ConfigPrefill()){
  2468.                 try{
  2469.                     ConfigurazionePdDReader.prefillCacheConInformazioniRegistro(OpenSPCoop2Startup.log);
  2470.                 }catch(Exception e){
  2471.                     msgDiag.logStartupError(e,"Prefill ConfigurazionePdD e Registro Reader fallita");
  2472.                     return;
  2473.                 }
  2474.             }

  2476.             // Inizializza il reader del registro dei Servizi utilizzato nella configurazione
  2477.             /**try{
  2478.                 configurazionePdDReader.initializeRegistroServiziReader();
  2479.             }catch(Exception e){
  2480.                 msgDiag.logStartupError(e,"Inizializzazione Reader per il registro dei servizi utilizzato nella configurazione");
  2481.                 return;
  2482.             }*/


  2485.             
  2486.             
  2487.             
  2488.             
  2489.             
  2490.             
  2491.             
  2492.             /* ------------ PreLoading ------------- */
  2493.             
  2494.             if(propertiesReader.getConfigPreLoadingLocale()!=null) {
  2495.                 try{
  2496.                     
  2497.                     Object oConfig = ConfigurazionePdDReader.getDriverConfigurazionePdD();
  2498.                     Object oRegistry = RegistroServiziReader.getDriverRegistroServizi().values().iterator().next();
  2499.                     if( (oConfig instanceof DriverConfigurazioneDB) && (oRegistry instanceof DriverRegistroServiziDB) ) {
  2500.                         PreLoadingConfig preLoading = new PreLoadingConfig(logCore, logCore, propertiesReader.getDefaultProtocolName(),
  2501.                                 propertiesReader.getIdentitaPortaDefault(propertiesReader.getDefaultProtocolName(), null));
  2502.                         
  2503.                         TimerLock timerLock = new TimerLock(TipoLock.STARTUP);
  2504.                         InfoStatistics semaphore_statistics = null;
  2505.                         Semaphore semaphore = null;
  2506.                         Logger logTimer = OpenSPCoop2Logger.getLoggerOpenSPCoopTimers();
  2507.                         if(propertiesReader.isTimerLockByDatabase()) {
  2508.                             semaphore_statistics = new InfoStatistics();

  2510.                             SemaphoreConfiguration config = GestoreMessaggi.newSemaphoreConfiguration(propertiesReader.getStartupLockMaxLife(), 
  2511.                                     propertiesReader.getStartupLockIdleTime());

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







  2566.             // *** Repository plugins ***
  2567.             try{
  2568.                 if(propertiesReader.isConfigurazionePluginsEnabled()) {
  2569.                     CorePluginLoader.initialize(loader, OpenSPCoop2Logger.getLoggerOpenSPCoopPlugins(propertiesReader.isConfigurazionePluginsDebug()),
  2570.                             PddPluginLoader.class,
  2571.                             configurazionePdDManager.getRegistroPluginsReader(),
  2572.                             propertiesReader.getConfigurazionePluginsSeconds());
  2573.                 }
  2574.                 else {
  2575.                     CorePluginLoader.initialize(loader, OpenSPCoop2Logger.getLoggerOpenSPCoopPlugins(propertiesReader.isConfigurazionePluginsDebug()),
  2576.                             PddPluginLoader.class);
  2577.                 }
  2578.             }catch(Exception e){
  2579.                 msgDiag.logStartupError(e,"Inizializzazione plugins");
  2580.                 return;
  2581.             }
  2582.             
  2583.             
  2584.             
  2585.             




  2590.             /* ---------------- Validazione semantica -----------------------*/

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

  2630.             // Registro dei Servizi
  2631.             try{
  2632.                 RegistroServiziManager.getInstance().validazioneSemantica(true, propertiesReader.isValidazioneSemanticaRegistroServiziCheckURI(), 
  2633.                         protocolFactoryManager.getOrganizationTypesAsArray(),
  2634.                         protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.SOAP),
  2635.                         protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.REST),
  2636.                         classNameReader.getConnettore(),
  2637.                         propertiesReader.isValidazioneSemanticaRegistroServiziStartupXML(),
  2638.                         propertiesReader.isValidazioneSemanticaRegistroServiziStartup(),OpenSPCoop2Startup.log);        
  2639.                 if(propertiesReader.isValidazioneSemanticaRegistroServiziStartupXML()){
  2640.                     RegistroServiziManager.getInstance().setValidazioneSemanticaModificaRegistroServiziXML(propertiesReader.isValidazioneSemanticaRegistroServiziCheckURI(), 
  2641.                             protocolFactoryManager.getOrganizationTypesAsArray(),
  2642.                             protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.SOAP),
  2643.                             protocolFactoryManager.getServiceTypesAsArray(ServiceBinding.REST),
  2644.                             classNameReader.getConnettore());
  2645.                 }
  2646.             }catch(Exception e){
  2647.                 msgDiag.logStartupError(e,"Validazione semantica del registro dei servizi");
  2648.                 return;
  2649.             }

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



  2706.         
  2707.         
  2708.         
  2709.         
  2710.             /* ----------- Inizializzo GestoreMessaggi Cache ------------ */
  2711.             try{
  2712.                 GestoreMessaggi.initialize();
  2713.             }catch(Exception e){
  2714.                 msgDiag.logStartupError(e,"Cache GestoreMessaggi");
  2715.                 return;
  2716.             }
  2717.         
  2718.         
  2719.         
  2720.         
  2721.             
  2722.             /* ----------- Inizializzazione MessageSecurity ------------ */
  2723.             try{
  2724.                 String wssPropertiesFileExternalPWCallback = propertiesReader.getExternalPWCallbackPropertyFile();
  2725.                 if(wssPropertiesFileExternalPWCallback!=null){
  2726.                     ExternalPWCallback.initialize(wssPropertiesFileExternalPWCallback);
  2727.                 }
  2728.                 
  2729.                 // DEVE essere effettuata all'inizio, vedi sopra.
  2730.                 //org.apache.wss4j.dom.engine.WSSConfig.init();
  2731.                 
  2732.             }catch(Exception e){
  2733.                 msgDiag.logStartupError(e,"Inizializzazione MessageSecurity");
  2734.                 return;
  2735.             }

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

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

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

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


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

  3327.             
  3328.             
  3329.             
  3330.             
  3331.             
  3332.     
  3333.             
  3334.             
  3335.             
  3336.             // Inizializzazione Init Handler
  3337.             try{
  3338.                 InitContext initContext = new InitContext();
  3339.                 initContext.setLogCore(logCore);
  3340.                 initContext.setLogConsole(OpenSPCoop2Startup.log);
  3341.                 initContext.setPddContext(OpenSPCoop2Startup.this.pddContext);
  3342.                 GestoreHandlers.init(initContext, msgDiag,OpenSPCoop2Startup.log); // per avere gli init stampati su server log
  3343.             }catch(HandlerException e){
  3344.                 if(e.isEmettiDiagnostico()){
  3345.                     msgDiag.logStartupError(e,e.getIdentitaHandler());
  3346.                 }
  3347.                 else{
  3348.                     logCore.error(e.getMessage(),e);
  3349.                 }
  3350.                 return;
  3351.             }catch(Exception e){
  3352.                 msgDiag.logStartupError(e,"InitHandler");
  3353.                 return;
  3354.             }
  3355.             
  3356.             
  3357.             
  3358.             
  3359.             



  3363.             // Inizializzazione Timer per il check delle risorse
  3364.             try{
  3365.                 if( propertiesReader.isAbilitatoControlloRisorseConfigurazione() ||
  3366.                         propertiesReader.isAbilitatoControlloValidazioneSemanticaConfigurazione() ||
  3367.                         propertiesReader.isAbilitatoControlloRisorseDB() ||
  3368.                         propertiesReader.isAbilitatoControlloRisorseJMS() ||
  3369.                         propertiesReader.isAbilitatoControlloRisorseMsgDiagnosticiPersonalizzati() || 
  3370.                         propertiesReader.isAbilitatoControlloRisorseRegistriServizi() ||
  3371.                         propertiesReader.isAbilitatoControlloValidazioneSemanticaRegistriServizi() ||
  3372.                         propertiesReader.isAbilitatoControlloRisorseTracciamentiPersonalizzati()){
  3373.                     OpenSPCoop2Startup.this.timerMonitoraggioRisorse = new TimerMonitoraggioRisorseThread();
  3374.                     OpenSPCoop2Startup.this.timerMonitoraggioRisorse.start();
  3375.                     TimerMonitoraggioRisorseThread.setSTATE( TimerState.ENABLED );
  3376.                     OpenSPCoop2Startup.logStartupInfo("Inizializzo Timer per il Monitoraggio delle Risorse");
  3377.                 }
  3378.             }catch(Exception e){
  3379.                 msgDiag.logStartupError(e,"TimerMonitoraggioRisorse");
  3380.                 return;
  3381.             }





  3387.             // Inizializzazione Timer per il check del Threshold
  3388.             try{
  3389.                 List<String> tipiThreshold = propertiesReader.getRepositoryThresholdTypes();
  3390.                 if(tipiThreshold!=null && !tipiThreshold.isEmpty()){
  3391.                     OpenSPCoop2Startup.this.timerThreshold = new TimerThresholdThread();
  3392.                     OpenSPCoop2Startup.this.timerThreshold.start();
  3393.                     TimerThresholdThread.setSTATE( TimerState.ENABLED );
  3394.                     OpenSPCoop2Startup.logStartupInfo("Inizializzo Timer per il Controllo dei Threshold sulle risorse");
  3395.                 }
  3396.             }catch(Exception e){
  3397.                 msgDiag.logStartupError(e,"TimerThreshold");
  3398.                 return;
  3399.             }






  3406.             // Inizializzazione delle risorse esterne terminata
  3407.             OpenSPCoop2Startup.initialize = true;
  3408.             Utilities.sleep(1000);








  3417.             /* -------- Check deploy timer ------ */
  3418.             boolean gestoreBusteNonRiscontrate = false;
  3419.             boolean gestoreMessaggi = false;
  3420.             boolean gestorePuliziaMessaggiAnomali = false;
  3421.             boolean gestoreRepository=false;
  3422.             if(OpenSPCoop2Startup.this.serverJ2EE){
  3423.                 long scadenzaWhile = System.currentTimeMillis() + propertiesReader.getTimerEJBDeployTimeout();
  3424.                 GestoreJNDI jndi = null;
  3425.                 if(propertiesReader.getJNDIContext_TimerEJB()==null)
  3426.                     jndi = new GestoreJNDI();
  3427.                 else
  3428.                     jndi = new GestoreJNDI(propertiesReader.getJNDIContext_TimerEJB());

  3430.                 while( (System.currentTimeMillis() < scadenzaWhile)
  3431.                         && 
  3432.                         (gestoreBusteNonRiscontrate==false
  3433.                                 || gestoreMessaggi==false
  3434.                                 || gestorePuliziaMessaggiAnomali==false
  3435.                                 || gestoreRepository==false)){

  3437.                     gestoreBusteNonRiscontrate = false;
  3438.                     gestoreMessaggi = false;
  3439.                     gestorePuliziaMessaggiAnomali = false;
  3440.                     gestoreRepository=false;

  3442.                     // check Timer Gestore Riscontri
  3443.                     if(propertiesReader.isTimerGestoreRiscontriRicevuteAbilitato()){
  3444.                         try{
  3445.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreBusteNonRiscontrate.ID_MODULO);
  3446.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore riscontri ["+nomeJNDI+"]");
  3447.                             jndi.lookup(nomeJNDI);
  3448.                             gestoreBusteNonRiscontrate = true;
  3449.                         }catch(Exception e){
  3450.                             this.logError("Search EJB gestore riscontri non trovato: "+e.getMessage(),e);
  3451.                             try {
  3452.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3453.                             }catch(Exception eRandom){
  3454.                                 // ignore
  3455.                             }
  3456.                             continue;
  3457.                         }
  3458.                     }else{
  3459.                         gestoreBusteNonRiscontrate = true;
  3460.                     }

  3462.                     //  check Timer Gestore Messaggi
  3463.                     if(propertiesReader.isTimerGestoreMessaggiAbilitato()){
  3464.                         try{
  3465.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreMessaggi.ID_MODULO);
  3466.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore messaggi ["+nomeJNDI+"]");
  3467.                             jndi.lookup(nomeJNDI);
  3468.                             gestoreMessaggi = true;
  3469.                         }catch(Exception e){
  3470.                             this.logError("Search EJB gestore messaggi non trovato: "+e.getMessage(),e);
  3471.                             try{
  3472.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3473.                             }catch(Exception eRandom){
  3474.                                 // ignore
  3475.                             }
  3476.                             continue;
  3477.                         }
  3478.                     }else{
  3479.                         gestoreMessaggi = true;
  3480.                     }

  3482.                     //  check Timer Gestore Pulizia Messaggi Anomali
  3483.                     if(propertiesReader.isTimerGestorePuliziaMessaggiAnomaliAbilitato()){
  3484.                         try{
  3485.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestorePuliziaMessaggiAnomali.ID_MODULO);
  3486.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore pulizia messaggi anomali ["+nomeJNDI+"]");
  3487.                             jndi.lookup(nomeJNDI);
  3488.                             gestorePuliziaMessaggiAnomali = true;
  3489.                         }catch(Exception e){
  3490.                             this.logError("Search EJB pulizia messaggi anomali non trovato: "+e.getMessage(),e);
  3491.                             try{
  3492.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3493.                             }catch(Exception eRandom){
  3494.                                 // ignore
  3495.                             }
  3496.                             continue;
  3497.                         }
  3498.                     }else{
  3499.                         gestorePuliziaMessaggiAnomali = true;
  3500.                     }


  3503.                     //  check Timer Gestore Repository
  3504.                     if(propertiesReader.isTimerGestoreRepositoryBusteAbilitato()){
  3505.                         try{
  3506.                             String nomeJNDI = propertiesReader.getJNDITimerEJBName().get(TimerGestoreRepositoryBuste.ID_MODULO);
  3507.                             OpenSPCoop2Startup.logStartupInfo("Inizializzo EJB gestore repository ["+nomeJNDI+"]");
  3508.                             jndi.lookup(nomeJNDI);
  3509.                             gestoreRepository = true;
  3510.                         }catch(Exception e){
  3511.                             this.logError("Search EJB gestore repository non trovato: "+e.getMessage(),e);
  3512.                             try{
  3513.                                 Utilities.sleep((RandomUtilities.getRandom()).nextInt(propertiesReader.getTimerEJBDeployCheckInterval())); // random da 0ms a TransactionManagerCheckInterval ms
  3514.                             }catch(Exception eRandom){
  3515.                                 // ignore
  3516.                             }
  3517.                             continue;
  3518.                         }
  3519.                     }else{
  3520.                         gestoreRepository = true;
  3521.                     }
  3522.                 }
  3523.             }






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









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









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







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




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

  4107.             /* ------------ Jminix StandaloneMiniConsole  ------------ */
  4108.             if(propertiesReader.getPortJminixConsole()!=null){
  4109.                 try{
  4110.                     jminixStandaloneConsole = new StandaloneMiniConsole(propertiesReader.getPortJminixConsole());
  4111.                     log.info("JminixStandaloneConsole correttamente avviata");
  4112.                     logCore.info("JminixStandaloneConsole correttamente avviata");
  4113.                 }catch(Throwable e){
  4114.                     logCore.error("Errore durante l'avvio della jminixStandaloneConsole: "+e.getMessage(),e);
  4115.                     msgDiag.logStartupError(e,"Inizializzazione JminixStandaloneConsole");
  4116.                 }
  4117.             }
  4118.             
  4119.             
  4120.             




  4125.             /* ------------ OpenSPCoop startup terminato  ------------ */
  4126.             long endDate = System.currentTimeMillis();
  4127.             long secondStarter = (endDate - OpenSPCoop2Startup.this.startDate) / 1000;
  4128.             msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_OPENSPCOOP_STARTUP);
  4129.             msgDiag.addKeyword(CostantiPdD.KEY_VERSIONE_PORTA, propertiesReader.getPddDetailsForLog());
  4130.             msgDiag.addKeyword(CostantiPdD.KEY_TEMPO_AVVIO, secondStarter+" secondi");
  4131.             OpenSPCoop2Startup.logStartupInfo(propertiesReader.getPddDetailsForLog()+" avviata correttamente in "+secondStarter+" secondi.");
  4132.             if(OpenSPCoop2Logger.isLoggerOpenSPCoopConsoleStartupAgganciatoLog()){
  4133.                 // per farlo finire anche sul server.log
  4134.                 System.out.println(propertiesReader.getPddDetailsForLog()+" avviata correttamente in "+secondStarter+" secondi.");
  4135.             }
  4136.             msgDiag.logPersonalizzato("pdd");
  4137.             MsgDiagnostico msgIM = MsgDiagnostico.newInstance(IntegrationManager.ID_MODULO);
  4138.             msgIM.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_OPENSPCOOP_STARTUP);
  4139.             msgIM.addKeyword(CostantiPdD.KEY_VERSIONE_PORTA, propertiesReader.getPddDetailsForLog());
  4140.             msgIM.addKeyword(CostantiPdD.KEY_TEMPO_AVVIO, secondStarter+" secondi");
  4141.             msgIM.logPersonalizzato("IntegrationManager");
  4142.             

  4144.         }

  4146.     }
  4147.     
  4148.     private static void setSystemProperties(String propName, String propValue) {
  4149.         System.setProperty(propName, propValue);
  4150.         OpenSPCoop2Startup.logStartupInfo("Hazelcast - '"+propName+"': "+System.getProperty(propName));
  4151.     }
  4152.     
  4153.     public static void startTimerClusterDinamicoThread() throws Exception {
  4154.         if(OpenSPCoop2Startup.threadClusterDinamico == null) {
  4155.             initTimerClusterDinamicoThread();
  4156.         }
  4157.     }
  4158.     private static synchronized void initTimerClusterDinamicoThread() throws Exception {
  4159.         if(OpenSPCoop2Startup.threadClusterDinamico == null) {
  4160.             Logger forceLogEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(true);
  4161.             OpenSPCoop2Startup.threadClusterDinamico = new TimerClusterDinamicoThread(OpenSPCoop2Logger.getLoggerOpenSPCoopTimers());
  4162.             OpenSPCoop2Startup.threadClusterDinamico.start();
  4163.             TimerClusterDinamicoThread.setSTATE( TimerState.ENABLED );
  4164.             forceLogEventi.info("Thread per l'aggiornamento del cluster avviato correttamente");
  4165.         }
  4166.     }
  4167.     
  4168.     public static boolean isStartedTimerClusteredRateLimitingLocalCache() {
  4169.         return OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache!=null;
  4170.     }
  4171.     public static void startTimerClusteredRateLimitingLocalCache(GestorePolicyAttiveInMemory gestore) throws Exception {
  4172.         if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache == null) {
  4173.             initTimerClusteredRateLimitingLocalCache(gestore);
  4174.         }
  4175.     }
  4176.     private static synchronized void initTimerClusteredRateLimitingLocalCache(GestorePolicyAttiveInMemory gestore) throws Exception {
  4177.         if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache == null) {
  4178.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  4179.             Logger logControlloTraffico = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(true);//properties.isControlloTrafficoDebug());
  4180.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache = new TimerClusteredRateLimitingLocalCache(OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), gestore);
  4181.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.setTimeout(properties.getControlloTrafficoGestorePolicyInMemoryHazelcastLocalCacheTimerUpdate());
  4182.             OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.start();
  4183.             logControlloTraffico.info("Thread per l'aggiornamento della LocalCache tramite Hazelcast avviato correttamente");
  4184.         }
  4185.     }
  4186.     
  4187.     
  4188.     /**
  4189.      * Undeploy dell'applicazione WEB di OpenSPCoop
  4190.      *
  4191.      * @param sce Servlet Context Event
  4192.      * 
  4193.      */
  4194.     @Override
  4195.     public void contextDestroyed(ServletContextEvent sce) {

  4197.         OpenSPCoop2Startup.setContextDestroyed(true);
  4198.         
  4199.         OpenSPCoop2Properties properties = null;
  4200.         try {
  4201.             properties = OpenSPCoop2Properties.getInstance();
  4202.         }catch(Throwable e){
  4203.             // ignore
  4204.         }
  4205.         
  4206.         // ID Cluster
  4207.         try{
  4208.             if(OpenSPCoop2Startup.threadClusterDinamico!=null){
  4209.                 OpenSPCoop2Startup.threadClusterDinamico.setStop(true);
  4210.             }
  4211.         }catch(Throwable e){
  4212.             // ignore
  4213.         }
  4214.         try{
  4215.             boolean rateLimitingGestioneCluster = false;
  4216.             if(properties!=null && properties.isControlloTrafficoEnabled()) {
  4217.                 rateLimitingGestioneCluster = GestorePolicyAttive.isAttivo(PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES);
  4218.             }
  4219.             if( (properties!=null && properties.isClusterDinamico()) || rateLimitingGestioneCluster) {  
  4220.                 DynamicClusterManager.getInstance().unregister(OpenSPCoop2Startup.log);
  4221.             }
  4222.         }catch(Throwable e){
  4223.             // ignore
  4224.         }
  4225.         
  4226.         
  4227.         // Eventi
  4228.         try{
  4229.             if(properties!=null) {
  4230.                 String clusterID = properties.getClusterId(false);
  4231.                 boolean debugEventi = properties.isEventiDebug();
  4232.                 Logger logEventi = OpenSPCoop2Logger.getLoggerOpenSPCoopEventi(debugEventi);
  4233.                 Evento eventoShutdown = null;
  4234.                 try{
  4235.                     if(OpenSPCoop2Startup.this.gestoreEventi!=null){
  4236.                         if(properties.isEventiRegistrazioneStatoPorta()){
  4237.                             eventoShutdown = new Evento();
  4238.                             eventoShutdown.setTipo(TipoEvento.STATO_GATEWAY.getValue());
  4239.                             eventoShutdown.setCodice(CodiceEventoStatoGateway.STOP.getValue());
  4240.                             eventoShutdown.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  4241.                             eventoShutdown.setClusterId(clusterID);
  4242.                             OpenSPCoop2Startup.this.gestoreEventi.log(eventoShutdown,true);
  4243.                         }
  4244.                     }
  4245.                 }catch(Exception e){
  4246.                     // L'errore puo' avvenire poiche' lo shutdown puo' anche disattivare il datasource
  4247.                     logEventi.debug("Errore durante la segnalazione di shutdown ('Emissione Evento'): "+e.getMessage(),e);
  4248.                     if(eventoShutdown!=null){
  4249.                         try{
  4250.                             if(eventoShutdown.getOraRegistrazione()==null){
  4251.                                 eventoShutdown.setOraRegistrazione(DateManager.getDate());
  4252.                             }
  4253.                             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  4254.                             eventoShutdown.writeTo(bout, WriteToSerializerType.XML_JAXB);
  4255.                             bout.flush();
  4256.                             bout.close();
  4257.                             FileSystemSerializer.getInstance().registraEvento(bout.toByteArray(), eventoShutdown.getOraRegistrazione());
  4258.                         }catch(Exception eSerializer){
  4259.                             logEventi.error("Errore durante la registrazione su file system dell'evento: "+eSerializer.getMessage(),eSerializer);
  4260.                         }
  4261.                     }
  4262.                 }
  4263.     
  4264.                 if(properties.isEventiTimerEnabled()){
  4265.                     try{    
  4266.                         if(debugEventi)
  4267.                             logEventi.debug("Recupero thread per gli Eventi ...");
  4268.                         if(OpenSPCoop2Startup.this.threadEventi!=null){
  4269.                             OpenSPCoop2Startup.this.threadEventi.setStop(true);
  4270.                             if(debugEventi)
  4271.                                 logEventi.debug("Richiesto stop al thread per gli Eventi");
  4272.                         }else{
  4273.                             throw new CoreException("Thread per gli Eventi non trovato");
  4274.                         }
  4275.                     }catch(Exception e){
  4276.                         if(logEventi!=null){
  4277.                             if(debugEventi)
  4278.                                 logEventi.error("Errore durante la gestione dell'exit (ThreadEventi): "+e.getMessage(),e);
  4279.                         }
  4280.                     }
  4281.                 }
  4282.             }
  4283.         }catch(Throwable e){
  4284.             // ignore
  4285.         }
  4286.         
  4287.         // Recovery FileSystem
  4288.         try {
  4289.             if(properties!=null && properties.isFileSystemRecoveryTimerEnabled()){
  4290.                 boolean debugRecoveryFileSystem = properties.isFileSystemRecoveryDebug();
  4291.                 Logger logRecoveryFileSystem = OpenSPCoop2Logger.getLoggerOpenSPCoopFileSystemRecovery(debugRecoveryFileSystem);
  4292.                 if(debugRecoveryFileSystem)
  4293.                     logRecoveryFileSystem.debug("Recupero thread per il recovery da file system ...");
  4294.                 if(OpenSPCoop2Startup.this.threadFileSystemRecovery!=null){
  4295.                     OpenSPCoop2Startup.this.threadFileSystemRecovery.setStop(true);
  4296.                     if(debugRecoveryFileSystem)
  4297.                         logRecoveryFileSystem.debug("Richiesto stop al thread per il recovery da file system");
  4298.                 }else{
  4299.                     throw new CoreException("Thread per il recovery da file system non trovato");
  4300.                 }   
  4301.             }
  4302.         }catch(Throwable e){
  4303.             // ignore
  4304.         }
  4305.         
  4306.         // GestoreTransazioniStateful
  4307.         try {
  4308.             if(properties!=null && properties.isTransazioniStatefulEnabled()){
  4309.                 boolean debugTransazioniStateful = properties.isTransazioniStatefulDebug();
  4310.                 Logger logTransazioniStateful = OpenSPCoop2Logger.getLoggerOpenSPCoopTransazioniStateful(debugTransazioniStateful);
  4311.                 if(debugTransazioniStateful)
  4312.                     logTransazioniStateful.debug("Recupero thread per la gestione delle transazioni stateful ...");
  4313.                 if(OpenSPCoop2Startup.this.threadRepositoryStateful!=null){
  4314.                     OpenSPCoop2Startup.this.threadRepositoryStateful.setStop(true);
  4315.                     if(debugTransazioniStateful)
  4316.                         logTransazioniStateful.debug("Richiesto stop al thread per la gestione delle transazioni stateful");
  4317.                 }else{
  4318.                     throw new CoreException("Thread per la gestione delle transazioni stateful non trovato");
  4319.                 }   
  4320.             }
  4321.         }catch(Throwable e){
  4322.             // ignore
  4323.         }

  4325.         // Statistiche
  4326.         try{
  4327.             if(properties!=null && properties.isStatisticheGenerazioneEnabled()){
  4328.                 boolean debugStatistiche = properties.isStatisticheGenerazioneDebug();
  4329.                 
  4330.                 Logger logStatisticheOrarie = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_ORARIE, debugStatistiche);
  4331.                 if(debugStatistiche)
  4332.                     logStatisticheOrarie.debug("Recupero thread per la generazione delle statistiche orarie ...");
  4333.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie!=null){
  4334.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheOrarie.setStop(true);
  4335.                     if(debugStatistiche)
  4336.                         logStatisticheOrarie.debug("Richiesto stop al thread per la generazione delle statistiche orarie");
  4337.                 }else{
  4338.                     if(properties.isStatisticheGenerazioneBaseOrariaEnabled()) {
  4339.                         throw new CoreException("Thread per la generazione delle statistiche orarie non trovato");
  4340.                     }
  4341.                 }   
  4342.                 
  4343.                 Logger logStatisticheGiornaliere = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_GIORNALIERE, debugStatistiche);
  4344.                 if(debugStatistiche)
  4345.                     logStatisticheGiornaliere.debug("Recupero thread per la generazione delle statistiche giornaliere ...");
  4346.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere!=null){
  4347.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheGiornaliere.setStop(true);
  4348.                     if(debugStatistiche)
  4349.                         logStatisticheGiornaliere.debug("Richiesto stop al thread per la generazione delle statistiche giornaliere");
  4350.                 }else{
  4351.                     if(properties.isStatisticheGenerazioneBaseGiornalieraEnabled()) {
  4352.                         throw new CoreException("Thread per la generazione delle statistiche giornaliere non trovato");
  4353.                     }
  4354.                 }
  4355.                 
  4356.                 Logger logStatisticheSettimanali = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_SETTIMANALI, debugStatistiche);
  4357.                 if(debugStatistiche)
  4358.                     logStatisticheSettimanali.debug("Recupero thread per la generazione delle statistiche settimanali ...");
  4359.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali!=null){
  4360.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheSettimanali.setStop(true);
  4361.                     if(debugStatistiche)
  4362.                         logStatisticheSettimanali.debug("Richiesto stop al thread per la generazione delle statistiche settimanali");
  4363.                 }else{
  4364.                     if(properties.isStatisticheGenerazioneBaseSettimanaleEnabled()) {
  4365.                         throw new CoreException("Thread per la generazione delle statistiche settimanali non trovato");
  4366.                     }
  4367.                 }
  4368.                 
  4369.                 Logger logStatisticheMensili = OpenSPCoop2Logger.getLoggerOpenSPCoopStatistiche(TipoIntervalloStatistico.STATISTICHE_MENSILI, debugStatistiche);
  4370.                 if(debugStatistiche)
  4371.                     logStatisticheMensili.debug("Recupero thread per la generazione delle statistiche mensili ...");
  4372.                 if(OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili!=null){
  4373.                     OpenSPCoop2Startup.this.threadGenerazioneStatisticheMensili.setStop(true);
  4374.                     if(debugStatistiche)
  4375.                         logStatisticheMensili.debug("Richiesto stop al thread per la generazione delle statistiche mensili");
  4376.                 }else{
  4377.                     if(properties.isStatisticheGenerazioneBaseMensileEnabled()) {
  4378.                         throw new CoreException("Thread per la generazione delle statistiche mensili non trovato");
  4379.                     }
  4380.                 }   
  4381.                 
  4382.             }
  4383.         }catch (Throwable e) {
  4384.             // ignore
  4385.         }
  4386.         
  4387.         // Timer per la gestione delle chiavi da PDND 
  4388.         
  4389.         try{
  4390.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreChiaviPDNDEnabled){
  4391.                 boolean debug = properties.isGestoreChiaviPDNDDebug();
  4392.             
  4393.                 Logger logGestorePDND = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreChiaviPDND(debug);
  4394.                 if(debug)
  4395.                     logGestorePDND.debug("Recupero thread per la gestione delle chiavi PDND ...");
  4396.                 if(OpenSPCoop2Startup.this.threadGestoreChiaviPDND!=null){
  4397.                     OpenSPCoop2Startup.this.threadGestoreChiaviPDND.setStop(true);
  4398.                     if(debug)
  4399.                         logGestorePDND.debug("Richiesto stop al thread per la gestione delle chiavi PDND");
  4400.                 }else{
  4401.                     throw new CoreException("Thread per la gestione delle chiavi PDND non trovato");
  4402.                 }   
  4403.             }
  4404.         }catch (Throwable e) {
  4405.             // ignore
  4406.         }
  4407.         try{
  4408.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreChiaviPDNDEnabled){
  4409.                 boolean debug = properties.isGestoreChiaviPDNDDebug();
  4410.             
  4411.                 Logger logGestorePDND = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreChiaviPDND(debug);
  4412.                 if(debug)
  4413.                     logGestorePDND.debug("Recupero thread per la gestione della cache delle chiavi PDND ...");
  4414.                 if(OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND!=null){
  4415.                     OpenSPCoop2Startup.this.threadGestoreCacheChiaviPDND.setStop(true);
  4416.                     if(debug)
  4417.                         logGestorePDND.debug("Richiesto stop al thread per la gestione della cache delle chiavi PDND");
  4418.                 }else{
  4419.                     throw new CoreException("Thread per gestione della cache delle chiavi PDND non trovato");
  4420.                 }   
  4421.             }
  4422.         }catch (Throwable e) {
  4423.             // ignore
  4424.         }
  4425.         
  4426.         // Timer per la gestione delle operazioni remote in un cluster dinamico
  4427.         
  4428.         try{
  4429.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreOperazioniRemoteEnabled){
  4430.                 boolean debug = properties.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
  4431.             
  4432.                 Logger logGestoreOperazioniRemote = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreOperazioniRemote(debug);
  4433.                 if(debug)
  4434.                     logGestoreOperazioniRemote.debug("Recupero thread per la gestione delle operazioni remote ...");
  4435.                 if(OpenSPCoop2Startup.this.threadGestoreOperazioniRemote!=null){
  4436.                     OpenSPCoop2Startup.this.threadGestoreOperazioniRemote.setStop(true);
  4437.                     if(debug)
  4438.                         logGestoreOperazioniRemote.debug("Richiesto stop al thread per la gestione delle operazioni remote");
  4439.                 }else{
  4440.                     throw new CoreException("Thread per la gestione delle operazioni remote non trovato");
  4441.                 }   
  4442.             }
  4443.         }catch (Throwable e) {
  4444.             // ignore
  4445.         }
  4446.         try{
  4447.             if(properties!=null && OpenSPCoop2Startup.this.threadGestoreOperazioniRemoteEnabled){
  4448.                 boolean debug = properties.isProxyReadJMXResourcesAsyncProcessByTimerDebug();
  4449.             
  4450.                 Logger logGestoreOperazioniRemote = OpenSPCoop2Logger.getLoggerOpenSPCoopGestoreOperazioniRemote(debug);
  4451.                 if(debug)
  4452.                     logGestoreOperazioniRemote.debug("Recupero thread per lo svecchiamento delle operazioni remote ...");
  4453.                 if(OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote!=null){
  4454.                     OpenSPCoop2Startup.this.threadSvecchiamentoOperazioniRemote.setStop(true);
  4455.                     if(debug)
  4456.                         logGestoreOperazioniRemote.debug("Richiesto stop al thread per lo svecchiamento delle operazioni remote");
  4457.                 }else{
  4458.                     throw new CoreException("Thread per lo svecchiamento delle operazioni remote non trovato");
  4459.                 }   
  4460.             }
  4461.         }catch (Throwable e) {
  4462.             // ignore
  4463.         }
  4464.         
  4465.         // ExitHandler
  4466.         try{
  4467.             ExitContext context = new ExitContext();
  4468.             context.setPddContext(this.pddContext);
  4469.             context.setLogConsole(OpenSPCoop2Startup.log);
  4470.             context.setLogCore(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  4471.             GestoreHandlers.exit(context);
  4472.         }catch(Throwable e){
  4473.             // ignore
  4474.         }
  4475.         
  4476.         // Gestione Stato ControlloTraffico
  4477.         if(properties!=null && properties.isControlloTrafficoEnabled()){
  4478.             OutputStream out = null;
  4479.             Logger logControlloTraffico = null;
  4480.             List<PolicyGroupByActiveThreadsType> tipiGestorePolicyRateLimiting = null;
  4481.             try{
  4482.                 logControlloTraffico = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(properties.isControlloTrafficoDebug());
  4483.                 tipiGestorePolicyRateLimiting = GestorePolicyAttive.getTipiGestoriAttivi();
  4484.             }catch(Throwable e){
  4485.                 if(logControlloTraffico!=null){
  4486.                     logControlloTraffico.error("Errore durante la terminazione dei gestori delle policy di Rate Limiting: "+e.getMessage(),e);
  4487.                 }
  4488.             }
  4489.             if(tipiGestorePolicyRateLimiting!=null && !tipiGestorePolicyRateLimiting.isEmpty()) {
  4490.                 for (PolicyGroupByActiveThreadsType type : tipiGestorePolicyRateLimiting) {
  4491.                     try{
  4492.                         File fRepository = properties.getControlloTrafficoGestorePolicyFileSystemRecoveryRepository();
  4493.                         if(fRepository!=null){
  4494.                             if(fRepository.exists()==false){
  4495.                                 throw new CoreException("Directory ["+fRepository.getAbsolutePath()+"] not exists");
  4496.                             }
  4497.                             if(fRepository.isDirectory()==false){
  4498.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] is not directory");
  4499.                             }
  4500.                             if(fRepository.canRead()==false){
  4501.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot read");
  4502.                             }
  4503.                             if(fRepository.canWrite()==false){
  4504.                                 throw new CoreException("File ["+fRepository.getAbsolutePath()+"] cannot write");
  4505.                             }       
  4506.                             
  4507.                             File fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoImage(type));
  4508.                             out = new FileOutputStream(fDati, false); // se già esiste lo sovrascrive
  4509.                             GestorePolicyAttive.getInstance(type).serialize(out);
  4510.                             out.flush();
  4511.                             out.close();
  4512.                             out = null;
  4513.                             
  4514.                             boolean inizializzazioneAttiva = false;
  4515.                             // Il meccanismo di ripristino dell'immagine degli eventi non sembra funzionare
  4516.                             // Lascio comunque il codice se in futuro si desidera approfindire la questione
  4517.                             if(inizializzazioneAttiva) {
  4518.                                 fDati = new File(fRepository, GestorePolicyAttive.getControlloTrafficoEventiImage(type));
  4519.                                 NotificatoreEventi.getInstance().serialize(fDati);
  4520.                             }
  4521.                             
  4522.                         }
  4523.                     }catch(Throwable e){
  4524.                         if(logControlloTraffico!=null){
  4525.                             logControlloTraffico.error("Errore durante la terminazione dei gestori delle policy di Rate Limiting: "+e.getMessage(),e);
  4526.                         }
  4527.                     }finally{
  4528.                         try{
  4529.                             if(out!=null){
  4530.                                 out.flush();
  4531.                             }
  4532.                         }catch(Exception eClose){
  4533.                             // ignore
  4534.                         }
  4535.                         try{
  4536.                             if(out!=null){
  4537.                                 out.close();
  4538.                             }
  4539.                         }catch(Exception eClose){
  4540.                             // ignore
  4541.                         }
  4542.                     }
  4543.                 }
  4544.             }
  4545.             
  4546.             if (OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache != null) {
  4547.                 OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.setStop(true);      
  4548.             }
  4549.         }
  4550.         
  4551.         // Fermo timer runtime
  4552.         if(this.serverJ2EE){
  4553.             try {
  4554.                 if(this.timerRiscontri!=null)
  4555.                     this.timerRiscontri.stop();
  4556.             } catch (Throwable e) {
  4557.                 // ignore
  4558.             }
  4559.             try {
  4560.                 if(this.timerEliminazioneMsg!=null)
  4561.                     this.timerEliminazioneMsg.stop();
  4562.             } catch (Throwable e) {
  4563.                 // ignore
  4564.             }
  4565.             try {
  4566.                 if(this.timerPuliziaMsgAnomali!=null)
  4567.                     this.timerPuliziaMsgAnomali.stop();
  4568.             } catch (Throwable e) {
  4569.                 // ignore
  4570.             }
  4571.             try {
  4572.                 if(this.timerRepositoryBuste!=null)
  4573.                     this.timerRepositoryBuste.stop();
  4574.             } catch (Throwable e) {
  4575.                 // ignore
  4576.             }
  4577.         }else{
  4578.             try{
  4579.                 if(this.threadEliminazioneMsg!=null) {
  4580.                     this.threadEliminazioneMsg.setStop(true);
  4581.                 }
  4582.             }catch (Throwable e) {
  4583.                 // ignore
  4584.             }
  4585.             try{
  4586.                 if(this.threadPuliziaMsgAnomali!=null)
  4587.                     this.threadPuliziaMsgAnomali.setStop(true);
  4588.             }catch (Throwable e) {
  4589.                 // ignore
  4590.             }
  4591.             try{
  4592.                 if(this.threadRepositoryBuste!=null)
  4593.                     this.threadRepositoryBuste.setStop(true);
  4594.             }catch (Throwable e) {
  4595.                 // ignore
  4596.             }
  4597.         }
  4598.         try{
  4599.             if(this.threadConsegnaContenutiApplicativiMap!=null && !this.threadConsegnaContenutiApplicativiMap.isEmpty()) {
  4600.                 for (String coda : this.threadConsegnaContenutiApplicativiMap.keySet()) {
  4601.                     TimerConsegnaContenutiApplicativiThread timer = this.threadConsegnaContenutiApplicativiMap.get(coda);
  4602.                     timer.setStop(true);
  4603.                 }
  4604.             }
  4605.         }catch (Throwable e) {
  4606.             // ignore
  4607.         }

  4609.         // fermo timer Monitoraggio Risorse
  4610.         try{
  4611.             if(this.timerMonitoraggioRisorse!=null)
  4612.                 this.timerMonitoraggioRisorse.setStop(true);
  4613.         }catch (Throwable e) {
  4614.             // ignore
  4615.         }

  4617.         // fermo timer Threshold
  4618.         try{
  4619.             if(this.timerThreshold!=null)
  4620.                 this.timerThreshold.setStop(true);
  4621.         }catch (Throwable e) {
  4622.             // ignore
  4623.         }

  4625.         // Rilascio risorse JMX
  4626.         if(this.gestoreRisorseJMX!=null){
  4627.             this.gestoreRisorseJMX.unregisterMBeans();
  4628.         }

  4630.         // Verifico che i timer siano conclusi prima di rilasciare i lock
  4631.         try{
  4632.             if(this.threadEventi!=null)
  4633.                 this.threadEventi.waitShutdown();
  4634.         }catch (Throwable e) {
  4635.             // ignore
  4636.         }
  4637.         try{
  4638.             if(this.threadFileSystemRecovery!=null)
  4639.                 this.threadFileSystemRecovery.waitShutdown();
  4640.         }catch (Throwable e) {
  4641.             // ignore
  4642.         }
  4643.         try{
  4644.             if(this.threadRepositoryStateful!=null)
  4645.                 this.threadRepositoryStateful.waitShutdown();
  4646.         }catch (Throwable e) {
  4647.             // ignore
  4648.         }
  4649.         try{
  4650.             if(this.threadGenerazioneStatisticheOrarie!=null)
  4651.                 this.threadGenerazioneStatisticheOrarie.waitShutdown();
  4652.         }catch (Throwable e) {
  4653.             // ignore
  4654.         }
  4655.         try{
  4656.             if(this.threadGenerazioneStatisticheGiornaliere!=null)
  4657.                 this.threadGenerazioneStatisticheGiornaliere.waitShutdown();
  4658.         }catch (Throwable e) {
  4659.             // ignore
  4660.         }
  4661.         try{
  4662.             if(this.threadGenerazioneStatisticheSettimanali!=null)
  4663.                 this.threadGenerazioneStatisticheSettimanali.waitShutdown();
  4664.         }catch (Throwable e) {
  4665.             // ignore
  4666.         }
  4667.         try{
  4668.             if(this.threadGenerazioneStatisticheMensili!=null)
  4669.                 this.threadGenerazioneStatisticheMensili.waitShutdown();
  4670.         }catch (Throwable e) {
  4671.             // ignore
  4672.         }
  4673.         if(this.serverJ2EE){ // TODO ATTESA ATTIVA CHE SI FERMINO PER J2EE
  4674.             Utilities.sleep(5000); // aspetto che i timer terminano la loro gestione.
  4675.         }
  4676.         else {
  4677.             try{
  4678.                 if(this.threadEliminazioneMsg!=null) {
  4679.                     this.threadEliminazioneMsg.waitShutdown();
  4680.                 }
  4681.             }catch (Throwable e) {
  4682.                 // ignore
  4683.             }
  4684.             try{
  4685.                 if(this.threadPuliziaMsgAnomali!=null) {
  4686.                     this.threadPuliziaMsgAnomali.waitShutdown();
  4687.                 }
  4688.             }catch (Throwable e) {
  4689.                 // ignore
  4690.             }
  4691.             try{
  4692.                 if(this.threadRepositoryBuste!=null) {
  4693.                     this.threadRepositoryBuste.waitShutdown();
  4694.                 }
  4695.             }catch (Throwable e) {
  4696.                 // ignore
  4697.             }
  4698.         }
  4699.         try{
  4700.             if(this.threadConsegnaContenutiApplicativiMap!=null && !this.threadConsegnaContenutiApplicativiMap.isEmpty()) {
  4701.                 for (String coda : this.threadConsegnaContenutiApplicativiMap.keySet()) {
  4702.                     TimerConsegnaContenutiApplicativiThread timer = this.threadConsegnaContenutiApplicativiMap.get(coda);
  4703.                     timer.waitShutdown();
  4704.                 }
  4705.             }
  4706.         }catch (Throwable e) {
  4707.             // ignore
  4708.         }
  4709.         try{
  4710.             if(this.timerMonitoraggioRisorse!=null) {
  4711.                 this.timerMonitoraggioRisorse.waitShutdown();
  4712.             }
  4713.         }catch (Throwable e) {
  4714.             // ignore
  4715.         }
  4716.         try{
  4717.             if(this.timerThreshold!=null) {
  4718.                 this.timerThreshold.waitShutdown();
  4719.             }
  4720.         }catch (Throwable e) {
  4721.             // ignore
  4722.         }
  4723.         try{
  4724.             if(OpenSPCoop2Startup.threadClusterDinamico!=null)
  4725.                 OpenSPCoop2Startup.threadClusterDinamico.waitShutdown();
  4726.         }catch (Throwable e) {
  4727.             // ignore
  4728.         }
  4729.         try{
  4730.             if(OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache!=null)
  4731.                 OpenSPCoop2Startup.timerClusteredRateLimitingLocalCache.waitShutdown();
  4732.         }catch (Throwable e) {
  4733.             // ignore
  4734.         }
  4735.         
  4736.         // Rilascio lock (da fare dopo che i timer sono stati fermati)
  4737.         // L'errore puo' avvenire poiche' lo shutdown puo' anche disattivare il datasource
  4738.         boolean logErrorConnection = false;
  4739.         TimerUtils.relaseLockTimers(properties, ID_MODULO, OpenSPCoop2Logger.getLoggerOpenSPCoopTimers(), logErrorConnection);
  4740.         
  4741.         // UniversallyUniqueIdentifierProducer (fermo dopo lo stop di tutte le altre attivita)
  4742.         try{
  4743.             if(OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer!=null){
  4744.                 OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer.setStop(true);
  4745.                 OpenSPCoop2Startup.this.universallyUniqueIdentifierProducer.waitShutdown();
  4746.             }
  4747.         }catch(Throwable e){
  4748.             // ignore
  4749.         }
  4750.         
  4751.         // DataManger
  4752.         DateManager.close();

  4754.         // Jminix StandaloneMiniConsole
  4755.         try{
  4756.             if(jminixStandaloneConsole!=null){
  4757.                 jminixStandaloneConsole.shutdown();
  4758.             }
  4759.         }catch (Throwable e) {
  4760.             // ignore
  4761.         }

  4763.         // *** Repository plugins ***
  4764.         try{
  4765.             CorePluginLoader.close(OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  4766.         }catch(Throwable e){
  4767.             // ignore
  4768.         }
  4769.         
  4770.         // *** Hazelcast ***
  4771.         if(properties!=null && properties.isControlloTrafficoEnabled()){
  4772.             HazelcastManager.close();
  4773.         }
  4774.         
  4775.         // *** Semaphore **
  4776.         try{
  4777.             org.openspcoop2.utils.SemaphoreLock.releaseScheduledExecutorService();
  4778.         }catch(Throwable e){
  4779.             // ignore
  4780.         }
  4781.         
  4782.         // Attendo qualche secondo
  4783.         Utilities.sleep(2000);
  4784.     }



  4788. }
Created with JaCoCo 0.8.8.202204050719