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


  22. package org.openspcoop2.core.monitor.rs.server.config;

  24. import java.io.File;
  25. import java.io.InputStream;
  26. import java.sql.Connection;
  27. import java.util.HashMap;
  28. import java.util.List;
  29. import java.util.Map;
  30. import java.util.Properties;

  32. import javax.servlet.ServletContextEvent;
  33. import javax.servlet.ServletContextListener;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.core.registry.constants.PddTipologia;
  39. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  40. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  41. import org.openspcoop2.core.registry.driver.FiltroRicerca;
  42. import org.openspcoop2.core.registry.driver.FiltroRicercaSoggetti;
  43. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  44. import org.openspcoop2.core.transazioni.utils.DumpUtils;
  45. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  46. import org.openspcoop2.pdd.config.ConfigurazioneNodiRuntime;
  47. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  48. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  49. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  50. import org.openspcoop2.pdd.services.ServicesUtils;
  51. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  52. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  53. import org.openspcoop2.utils.LoggerWrapperFactory;
  54. import org.openspcoop2.utils.UtilsException;
  55. import org.openspcoop2.utils.UtilsRuntimeException;
  56. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  57. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  58. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  59. import org.openspcoop2.utils.properties.MapProperties;
  60. import org.openspcoop2.utils.resources.Loader;
  61. import org.openspcoop2.utils.security.ProviderUtils;
  62. import org.openspcoop2.web.monitor.core.bean.LoginBean;
  63. import org.openspcoop2.web.monitor.core.core.Utility;
  64. import org.slf4j.Logger;
  65. /**
  66.  * Questa classe si occupa di inizializzare tutte le risorse necessarie al webService.
  67.  * 
  68.  * 
  69.  * @author Andrea Poli (apoli@link.it)
  70.  * @author $Author$
  71.  * @version $Rev$, $Date$
  72.  * 
  73.  */

  75. public class Startup implements ServletContextListener {

  77.     private static Logger log = null;
  78.     public static Logger getLog() {
  79.         return log;
  80.     }
  81.     
  82.     private static InitRuntimeConfigReader initRuntimeConfigReader;
  83.     
  84.     
  85.     @Override
  86.     public void contextDestroyed(ServletContextEvent sce) {
  87.         if(Startup.log!=null)
  88.             Startup.log.info("Undeploy webService in corso...");

  90.          if(initRuntimeConfigReader!=null) {
  91.              initRuntimeConfigReader.setStop(true);
  92.          }
  93.         
  94.         if(Startup.log!=null)
  95.             Startup.log.info("Undeploy webService effettuato.");

  97.     }

  99.     @Override
  100.     public void contextInitialized(ServletContextEvent sce) {
  101.         
  102.         Startup.initLog();
  103.         
  104.         Startup.initResources();

  106.     }
  107.     
  108.     
  109.     // LOG
  110.     
  111.     private static boolean initializedLog = false;
  112.     public static boolean isInitializedLog() {
  113.         return initializedLog;
  114.     }

  116.     public static synchronized String initLog(){
  117.         
  118.         String confDir = null;
  119.         try{
  120.             InputStream is = Startup.class.getResourceAsStream("/rs-api-monitor.properties");
  121.             try{
  122.                 if(is!=null){
  123.                     Properties p = new Properties();
  124.                     p.load(is);
  125.                     confDir = p.getProperty("confDirectory");
  126.                     if(confDir!=null){
  127.                         confDir = confDir.trim();
  128.                     }
  129.                 }
  130.             }finally{
  131.                 try{
  132.                     if(is!=null){
  133.                         is.close();
  134.                     }
  135.                 }catch(Exception eClose){
  136.                     // close
  137.                 }
  138.             }

  140.         }catch(Exception e){
  141.             // ignore
  142.         }
  143.         
  144.         if(!Startup.initializedLog){
  145.             
  146.             try{
  147.                 Startup.log = LoggerWrapperFactory.getLogger(Startup.class);
  148.                 LoggerProperties.initialize(Startup.log, confDir, null);
  149.                 Startup.initializedLog = true;
  150.                 Startup.log = LoggerProperties.getLoggerCore();
  151.                 
  152.             }catch(Exception e){
  153.                 throw new UtilsRuntimeException(e.getMessage(),e);
  154.             }
  155.         }
  156.         
  157.         return confDir;
  158.     }
  159.     
  160.     
  161.     // RESOURCES
  162.     
  163.     private static boolean initializedResources = false;
  164.     
  165.     public static synchronized void initResources(){
  166.         if(!Startup.initializedResources){
  167.             
  168.             String confDir = Startup.initLog();
  169.             
  170.             Startup.log.info("Inizializzazione rs api monitor in corso...");
  171.             
  172.             if(!ServerProperties.initialize(confDir,Startup.log)){
  173.                 return;
  174.             }
  175.             ServerProperties serverProperties = null;
  176.             try {
  177.                 serverProperties = ServerProperties.getInstance();
  178.             } catch (Exception e) {
  179.                 doError("Errore durante l'inizializzazione del serverProperties",e);
  180.             }
  181.             
  182.             // Inizializzo Controlli connessioni
  183.             try {
  184.                 Logger logR = Startup.log;
  185.                 ServicesUtils.initCheckConnectionDB(logR, serverProperties.isJdbcCloseConnectionCheckIsClosed(), serverProperties.isJdbcCloseConnectionCheckAutocommit());
  186.                 
  187.                 DBManager.setCheckLogger(logR);
  188.                 DBManager.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  189.                 DBManager.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  190.             } catch (Exception e) {
  191.                 doError("Inizializzazione controlli connessione non riuscita",e);
  192.             }
  193.             
  194.             // Map (environment)
  195.             try {
  196.                 String mapConfig = serverProperties.getEnvMapConfig();
  197.                 if(StringUtils.isNotEmpty(mapConfig)) {
  198.                     Startup.log.info("Inizializzazione environment in corso...");
  199.                     MapProperties.initialize(Startup.log, mapConfig, serverProperties.isEnvMapConfigRequired());
  200.                     MapProperties mapProperties = MapProperties.getInstance();
  201.                     mapProperties.initEnvironment();
  202.                     String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  203.                             "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  204.                             "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  205.                             "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  206.                             "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  207.                             "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  208.                     Startup.log.info(msgInit);
  209.                 }
  210.             } catch (Exception e) {
  211.                 doError("Errore durante l'inizializzazione dell'ambiente",e);
  212.             }
  213.             
  214.             // Load Security Provider
  215.             Startup.log.info("Inizializzazione security provider...");
  216.             try {
  217.                 if(serverProperties.isSecurityLoadBouncyCastleProvider()) {
  218.                     ProviderUtils.addBouncyCastleAfterSun(true);
  219.                     Startup.log.info("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  220.                 }
  221.             } catch (Exception e) {
  222.                 doError("Errore durante l'inizializzazione dei security provider",e);
  223.             }
  224.             Startup.log.info("Inizializzazione security provider effettuata con successo");
  225.             
  226.             // inizializzo HSM Manager
  227.             try {
  228.                 String hsmConfig = serverProperties.getHSMConfigurazione();
  229.                 if(StringUtils.isNotEmpty(hsmConfig)) {
  230.                     Startup.log.info("Inizializzazione HSM in corso...");
  231.                     File f = new File(hsmConfig);
  232.                     HSMManager.init(f, serverProperties.isHSMRequired(), log, false);
  233.                     HSMUtils.setHsmConfigurableKeyPassword(serverProperties.isHSMKeyPasswordConfigurable());
  234.                     Startup.log.info("Inizializzazione HSM effettuata con successo");
  235.                 }
  236.             } catch (Exception e) {
  237.                 doError("Errore durante l'inizializzazione del manager HSM",e);
  238.             }
  239.             
  240.             // inizializzo BYOK Manager
  241.             BYOKManager byokManager = null;
  242.             try {
  243.                 String byokConfig = serverProperties.getBYOKConfigurazione();
  244.                 if(StringUtils.isNotEmpty(byokConfig)) {
  245.                     Startup.log.info("Inizializzazione BYOK in corso...");
  246.                     File f = new File(byokConfig);
  247.                     BYOKManager.init(f, serverProperties.isBYOKRequired(), log);
  248.                     byokManager = BYOKManager.getInstance();
  249.                     String msgInit = "Gestore BYOK inizializzato;"+
  250.                             "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  251.                             "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  252.                             "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  253.                     Startup.log.info(msgInit);
  254.                 }
  255.             } catch (Exception e) {
  256.                 doError("Errore durante l'inizializzazione del manager BYOK",e);
  257.             }
  258.             
  259.             // Secrets (environment)
  260.             boolean reInitSecretMaps = false;
  261.             try {
  262.                 String secretsConfig = serverProperties.getBYOKEnvSecretsConfig();
  263.                 if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  264.                     Startup.log.info("Inizializzazione secrets in corso...");
  265.                     
  266.                     boolean useSecurityEngine = true;
  267.                     Map<String, Object> dynamicMap = new HashMap<>();
  268.                     DynamicInfo dynamicInfo = new  DynamicInfo();
  269.                     DynamicUtils.fillDynamicMap(log, dynamicMap, dynamicInfo);
  270.                     if(byokManager.isBYOKRemoteGovWayNodeUnwrapConfig()) {
  271.                         // i secrets cifrati verranno riletti quando i nodi sono attivi (verificato in InitRuntimeConfigReader)
  272.                         reInitSecretMaps = true;
  273.                         useSecurityEngine = false;
  274.                     }
  275.                     
  276.                     BYOKMapProperties.initialize(Startup.log, secretsConfig, serverProperties.isBYOKEnvSecretsConfigRequired(), 
  277.                             useSecurityEngine, 
  278.                             dynamicMap, true);
  279.                     BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  280.                     secretsProperties.initEnvironment();
  281.                     String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"'"+
  282.                             "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  283.                             "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  284.                             "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription();
  285.                     Startup.log.info(msgInit);
  286.                 }
  287.             } catch (Exception e) {
  288.                 doError("Errore durante l'inizializzazione dell'ambiente (secrets)",e);
  289.             }       
  290.             
  291.             // Database
  292.             if(!DatasourceProperties.initialize(confDir,Startup.log)){
  293.                 return;
  294.             }
  295.             Startup.log.info("Inizializzazione DBManager in corso...");
  296.             try{
  297.                 DatasourceProperties dbProperties = DatasourceProperties.getInstance();
  298.                 DBManager.initialize(dbProperties.getConfigDataSource(), dbProperties.getConfigDataSourceContext(), dbProperties.getConfigTipoDatabase(),
  299.                         dbProperties.getTracceDataSource(), dbProperties.getTracceDataSourceContext(), dbProperties.getTracceTipoDatabase(),
  300.                         dbProperties.getStatisticheDataSource(), dbProperties.getStatisticheDataSourceContext(), dbProperties.getStatisticheTipoDatabase(),
  301.                         dbProperties.isShowSql());
  302.             }catch(Exception e){
  303.                 throw new UtilsRuntimeException(e.getMessage(),e);
  304.             }
  305.             Startup.log.info("Inizializzazione DBManager effettuata con successo");
  306.             
  307.             // Extended Manager
  308.             Startup.log.info("Inizializzazione ExtendedInfoManager in corso...");
  309.             try{
  310.                 ExtendedInfoManager.initialize(new Loader(), null, null, null);
  311.             }catch(Exception e){
  312.                 throw new UtilsRuntimeException(e.getMessage(),e);
  313.             }
  314.             Startup.log.info("Inizializzazione ExtendedInfoManager effettuata con successo");
  315.             
  316.             // inizializza nodi runtime
  317.             Startup.log.info("Inizializzazione NodiRuntime in corso...");
  318.             try {
  319.                 boolean configFileRequired = false;
  320.                 ConfigurazioneNodiRuntime.initialize(serverProperties.getConfigurazioneNodiRuntime(), configFileRequired);
  321.             } catch (Exception e) {
  322.                 doError("Errore durante l'inizializzazione del gestore dei nodi run",e);
  323.             }
  324.             Startup.log.info("Inizializzazione NodiRuntime effettuata con successo");
  325.             
  326.             // Protocol Factory Manager
  327.             Startup.log.info("Inizializzazione ProtocolFactoryManager in corso...");
  328.             ServerProperties properties = null;
  329.             try {
  330.                 properties = ServerProperties.getInstance();
  331.                 ConfigurazionePdD configPdD = new ConfigurazionePdD();
  332.                 configPdD.setAttesaAttivaJDBC(-1);
  333.                 configPdD.setCheckIntervalJDBC(-1);
  334.                 configPdD.setLoader(new Loader(Startup.class.getClassLoader()));
  335.                 configPdD.setLog(Startup.log);
  336.                 ProtocolFactoryManager.initialize(Startup.log, configPdD,
  337.                         properties.getProtocolloDefault());
  338.             } catch (Exception e) {
  339.                 throw new UtilsRuntimeException(e.getMessage(),e);
  340.             }
  341.             Startup.log.info("ProtocolFactoryManager DBManager effettuata con successo");
  342.             
  343.             // Risorse statiche
  344.             Startup.log.info("Inizializzazione Risorse Statiche Console in corso...");
  345.             try {
  346.                 initResourceConsole();
  347.             } catch (Exception e) {
  348.                 throw new UtilsRuntimeException(e.getMessage(),e);
  349.             }
  350.             Startup.log.info("Inizializzazione Risorse Statiche Console effettuata con successo");
  351.             
  352.             Startup.log.info("Inizializzazione Soglia per Dimensione Messaggi in corso...");
  353.             try {
  354.                 DumpUtils.setThreshold_readInMemory(properties.getTransazioniDettaglioVisualizzazioneMessaggiThreshold());
  355.             } catch (Exception e) {
  356.                 throw new UtilsRuntimeException(e.getMessage(),e);
  357.             }
  358.             Startup.log.info("Inizializzazione Soglia per Dimensione Messaggi effettuata con successo");
  359.                         
  360.             // InitRuntimeConfigReader
  361.             if(reInitSecretMaps) {
  362.                 try{
  363.                     initRuntimeConfigReader = new InitRuntimeConfigReader(serverProperties, ConfigurazioneNodiRuntime.getConfigurazioneNodiRuntime(), reInitSecretMaps);
  364.                     initRuntimeConfigReader.start();
  365.                     Startup.log.info("RuntimeConfigReader avviato con successo.");
  366.                 } catch (Exception e) {
  367.                     /**doError("Errore durante l'inizializzazione del RuntimeConfigReader",e);*/
  368.                     // non sollevo l'eccezione, e' solo una informazione informativa, non voglio mettere un vincolo che serve per forza un nodo acceso
  369.                     Startup.log.error("Errore durante l'inizializzazione del RuntimeConfigReader: "+e.getMessage(),e);
  370.                 }
  371.             }
  372.             
  373.             Startup.initializedResources = true;
  374.             
  375.             Startup.log.info("Inizializzazione rs api monitor effettuata con successo.");
  376.         }
  377.     }

  379.     
  380.     private static void initResourceConsole() throws UtilsException, DriverRegistroServiziException, DriverRegistroServiziNotFound {
  381.         DBManager dbManager = DBManager.getInstance();
  382.         Connection connection = null;
  383.         try {
  384.             connection = dbManager.getConnectionConfig();
  385.             ServiceManagerProperties smp = dbManager.getServiceManagerPropertiesConfig();
  386.             
  387.             Logger logSql = LoggerProperties.getLoggerDAO();
  388.             
  389.             LoginBean lb = new LoginBean(connection, true, smp, logSql);
  390.             
  391.             Utility.setStaticConfigurazioneGenerale(lb.getConfigurazioneGenerale());
  392.             
  393.             boolean multitenantAbilitato = Utility.isMultitenantAbilitato();
  394.             
  395.             Utility.setStaticFiltroDominioAbilitato(multitenantAbilitato); // logiche piu' complesse vanno viste come realizzarle.
  396.             
  397.             DriverRegistroServiziDB driverDB = new DriverRegistroServiziDB(connection, logSql, DatasourceProperties.getInstance().getConfigTipoDatabase());
  398.             
  399.             FiltroRicerca filtroRicercaPdd = new FiltroRicerca();
  400.             filtroRicercaPdd.setTipo(PddTipologia.OPERATIVO.toString());
  401.             List<String> idsPdd = null;
  402.             try {
  403.                 idsPdd = driverDB.getAllIdPorteDominio(filtroRicercaPdd);
  404.             }catch(DriverRegistroServiziNotFound notFound) {    
  405.                 // ignore
  406.             }
  407.             initPdd(idsPdd, driverDB);
  408.             
  409.         } finally {
  410.             dbManager.releaseConnectionConfig(connection);
  411.         }
  412.     }
  413.     private static void initPdd(List<String> idsPdd, DriverRegistroServiziDB driverDB) throws DriverRegistroServiziException, DriverRegistroServiziNotFound {
  414.         if(idsPdd!=null && !idsPdd.isEmpty()) {
  415.             for (String idPdd : idsPdd) {
  416.                 FiltroRicercaSoggetti filtroSoggetti = new FiltroRicercaSoggetti();
  417.                 filtroSoggetti.setNomePdd(idPdd);
  418.                 List<IDSoggetto> idsSoggetti = null;
  419.                 try {
  420.                     idsSoggetti = driverDB.getAllIdSoggetti(filtroSoggetti);
  421.                 }catch(DriverRegistroServiziNotFound notFound) {    
  422.                     // ignore
  423.                 }
  424.                 if(idsSoggetti!=null && !idsSoggetti.isEmpty()) {
  425.                     for (IDSoggetto idSoggetto : idsSoggetti) {
  426.                         Utility.putIdentificativoPorta(idSoggetto.getTipo(), idSoggetto.getNome(), driverDB.getSoggetto(idSoggetto).getIdentificativoPorta());
  427.                     }
  428.                 }
  429.             }
  430.         }
  431.     }
  432.     
  433.     private static void doError(String msg,Exception e) {
  434.         String msgErrore = msg+": " + e.getMessage();
  435.         Startup.log.error(msgErrore,e);
  436.         throw new UtilsRuntimeException(msgErrore,e);
  437.     }
  438. }
Created with JaCoCo 0.8.8.202204050719