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.config.rs.server.config;

  24. import java.io.File;
  25. import java.io.InputStream;
  26. import java.util.HashMap;
  27. import java.util.Map;
  28. import java.util.Properties;

  30. import javax.servlet.ServletContextEvent;
  31. import javax.servlet.ServletContextListener;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.commons.DBUtils;
  35. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  36. import org.openspcoop2.core.constants.CostantiDB;
  37. import org.openspcoop2.monitor.engine.alarm.AlarmConfigProperties;
  38. import org.openspcoop2.monitor.engine.alarm.AlarmEngineConfig;
  39. import org.openspcoop2.monitor.engine.alarm.AlarmManager;
  40. import org.openspcoop2.pdd.config.ConfigurazioneNodiRuntime;
  41. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  42. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  43. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  44. import org.openspcoop2.pdd.services.ServicesUtils;
  45. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  46. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  47. import org.openspcoop2.protocol.utils.ModIUtils;
  48. import org.openspcoop2.utils.LoggerWrapperFactory;
  49. import org.openspcoop2.utils.UtilsRuntimeException;
  50. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  51. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  52. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  53. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  54. import org.openspcoop2.utils.json.YamlSnakeLimits;
  55. import org.openspcoop2.utils.properties.MapProperties;
  56. import org.openspcoop2.utils.resources.Loader;
  57. import org.openspcoop2.utils.security.ProviderUtils;
  58. import org.openspcoop2.web.ctrlstat.core.Connettori;
  59. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  60. import org.openspcoop2.web.ctrlstat.core.DBManager;
  61. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  62. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  63. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  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.     }

  82.     private static InitRuntimeConfigReader initRuntimeConfigReader;
  83.     
  84.     @Override
  85.     public void contextDestroyed(ServletContextEvent sce) {
  86.         if(Startup.log!=null)
  87.             Startup.log.info("Undeploy webService in corso...");

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

  96.     }

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

  105.     }
  106.     

  108.     // LOG
  109.     
  110.     private static boolean initializedLog = false;
  111.     
  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-config.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 config 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.                 DriverControlStationDB.setCheckLogger(logR);
  188.                 DriverControlStationDB.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  189.                 DriverControlStationDB.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  190.                 DBManager.setCheckLogger(logR);
  191.                 DBManager.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  192.                 DBManager.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  193.             } catch (Exception e) {
  194.                 doError("Inizializzazione controlli connessione non riuscita",e);
  195.             }
  196.             
  197.             // Map (environment)
  198.             try {
  199.                 String mapConfig = serverProperties.getEnvMapConfig();
  200.                 if(StringUtils.isNotEmpty(mapConfig)) {
  201.                     Startup.log.info("Inizializzazione environment in corso...");
  202.                     MapProperties.initialize(Startup.log, mapConfig, serverProperties.isEnvMapConfigRequired());
  203.                     MapProperties mapProperties = MapProperties.getInstance();
  204.                     mapProperties.initEnvironment();
  205.                     String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  206.                             "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  207.                             "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  208.                             "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  209.                             "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  210.                             "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  211.                     Startup.log.info(msgInit);
  212.                 }
  213.             } catch (Exception e) {
  214.                 doError("Errore durante l'inizializzazione dell'ambiente",e);
  215.             }
  216.             
  217.             // Load Security Provider
  218.             Startup.log.info("Inizializzazione security provider...");
  219.             try {
  220.                 if(serverProperties.isSecurityLoadBouncyCastleProvider()) {
  221.                     ProviderUtils.addBouncyCastleAfterSun(true);
  222.                     Startup.log.info("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  223.                 }
  224.             } catch (Exception e) {
  225.                 doError("Errore durante l'inizializzazione dei security provider",e);
  226.             }
  227.             Startup.log.info("Inizializzazione security provider effettuata con successo");
  228.             
  229.             // inizializzo HSM Manager
  230.             try {
  231.                 String hsmConfig = serverProperties.getHSMConfigurazione();
  232.                 if(StringUtils.isNotEmpty(hsmConfig)) {
  233.                     Startup.log.info("Inizializzazione HSM in corso...");
  234.                     File f = new File(hsmConfig);
  235.                     HSMManager.init(f, serverProperties.isHSMRequired(), log, false);
  236.                     HSMUtils.setHsmConfigurableKeyPassword(serverProperties.isHSMKeyPasswordConfigurable());
  237.                     Startup.log.info("Inizializzazione HSM effettuata con successo");
  238.                 }
  239.             } catch (Exception e) {
  240.                 doError("Errore durante l'inizializzazione del manager HSM",e);
  241.             }
  242.             
  243.             // inizializzo BYOK Manager
  244.             BYOKManager byokManager = null;
  245.             try {
  246.                 String byokConfig = serverProperties.getBYOKConfigurazione();
  247.                 if(StringUtils.isNotEmpty(byokConfig)) {
  248.                     Startup.log.info("Inizializzazione BYOK in corso...");
  249.                     File f = new File(byokConfig);
  250.                     BYOKManager.init(f, serverProperties.isBYOKRequired(), log);
  251.                     byokManager = BYOKManager.getInstance();
  252.                     String msgInit = "Gestore BYOK inizializzato;"+
  253.                             "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  254.                             "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  255.                             "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  256.                     Startup.log.info(msgInit);
  257.                 }
  258.             } catch (Exception e) {
  259.                 doError("Errore durante l'inizializzazione del manager BYOK",e);
  260.             }
  261.             
  262.             // inizializzo OCSP Manager
  263.             Startup.log.info("Inizializzazione OCSP in corso...");
  264.             try {
  265.                 String ocspConfig = serverProperties.getOCSPConfigurazione();
  266.                 if(StringUtils.isNotEmpty(ocspConfig)) {
  267.                     File f = new File(ocspConfig);
  268.                     OCSPManager.init(f, serverProperties.isOCSPRequired(), serverProperties.isOCSPLoadDefault(), log);
  269.                 }
  270.             } catch (Exception e) {
  271.                 doError("Errore durante l'inizializzazione del manager OCSP",e);
  272.             }
  273.             Startup.log.info("Inizializzazione OCSP effettuata con successo");
  274.             
  275.             // Secrets (environment)
  276.             boolean reInitSecretMaps = false;
  277.             try {
  278.                 String secretsConfig = serverProperties.getBYOKEnvSecretsConfig();
  279.                 if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  280.                     Startup.log.info("Inizializzazione secrets in corso...");

  282.                     boolean useSecurityEngine = true;
  283.                     Map<String, Object> dynamicMap = new HashMap<>();
  284.                     DynamicInfo dynamicInfo = new  DynamicInfo();
  285.                     DynamicUtils.fillDynamicMap(log, dynamicMap, dynamicInfo);
  286.                     if(byokManager.isBYOKRemoteGovWayNodeUnwrapConfig()) {
  287.                         // i secrets cifrati verranno riletti quando i nodi sono attivi (verificato in InitRuntimeConfigReader)
  288.                         reInitSecretMaps = true;
  289.                         useSecurityEngine = false;
  290.                     }
  291.                     
  292.                     BYOKMapProperties.initialize(Startup.log, secretsConfig, serverProperties.isBYOKEnvSecretsConfigRequired(), 
  293.                             useSecurityEngine, 
  294.                             dynamicMap, true);
  295.                     BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  296.                     secretsProperties.initEnvironment();
  297.                     String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"'"+
  298.                             "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  299.                             "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  300.                             "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription();
  301.                     Startup.log.info(msgInit);
  302.                 }
  303.             } catch (Exception e) {
  304.                 doError("Errore durante l'inizializzazione dell'ambiente (secrets)",e);
  305.             }       
  306.             
  307.             // Database
  308.             if(!DatasourceProperties.initialize(confDir,Startup.log)){
  309.                 return;
  310.             }
  311.             try {
  312.                 if(!org.openspcoop2.web.ctrlstat.config.DatasourceProperties.initialize(DatasourceProperties.getInstance().getPropertiesConsole(),Startup.log)){
  313.                     return;
  314.                 }
  315.             }catch(Exception e) {
  316.                 Startup.log.error("Inizializzazione database console fallita: "+e.getMessage(),e);
  317.             }
  318.             
  319.             // Extended Manager
  320.             Startup.log.info("Inizializzazione ExtendedInfoManager in corso...");
  321.             try{
  322.                 ExtendedInfoManager.initialize(new Loader(), null, null, null);
  323.             }catch(Exception e){
  324.                 throw new UtilsRuntimeException(e.getMessage(),e);
  325.             }
  326.             Startup.log.info("Inizializzazione ExtendedInfoManager effettuata con successo");
  327.             
  328.             // inizializza nodi runtime
  329.             Startup.log.info("Inizializzazione NodiRuntime in corso...");
  330.             try {
  331.                 boolean configFileRequired = false;
  332.                 ConfigurazioneNodiRuntime.initialize(serverProperties.getConfigurazioneNodiRuntime(), configFileRequired);
  333.             } catch (Exception e) {
  334.                 doError("Errore durante l'inizializzazione del gestore dei nodi run",e);
  335.             }
  336.             Startup.log.info("Inizializzazione NodiRuntime effettuata con successo");
  337.             
  338.             
  339.             // Protocol Factory Manager
  340.             Startup.log.info("Inizializzazione ProtocolFactoryManager in corso...");
  341.             ServerProperties properties = null;
  342.             try {
  343.                 properties = ServerProperties.getInstance();
  344.                 ConfigurazionePdD configPdD = new ConfigurazionePdD();
  345.                 configPdD.setAttesaAttivaJDBC(-1);
  346.                 configPdD.setCheckIntervalJDBC(-1);
  347.                 configPdD.setLoader(new Loader(Startup.class.getClassLoader()));
  348.                 configPdD.setLog(Startup.log);
  349.                 ProtocolFactoryManager.initialize(Startup.log, configPdD,
  350.                         properties.getProtocolloDefault());
  351.             } catch (Exception e) {
  352.                 throw new UtilsRuntimeException(e.getMessage(),e);
  353.             }
  354.             Startup.log.info("ProtocolFactoryManager DBManager effettuata con successo");
  355.             
  356.             // Risorse Statiche
  357.             Startup.log.info("Inizializzazione Risorse Statiche Console in corso...");
  358.             try {
  359.                 ConsoleHelper.setTipoInterfacciaAPI(InterfaceType.STANDARD);
  360.                 
  361.                 ControlStationCore.setUtenzePasswordEncryptEngineApiMode(serverProperties.getUtenzeCryptConfig());
  362.                 
  363.                 ControlStationCore.setApplicativiPasswordEncryptEngineApiMode(serverProperties.getApplicativiCryptConfig());
  364.                 ControlStationCore.setApplicativiApiKeyPasswordGeneratedLengthApiMode(serverProperties.getApplicativiApiKeyPasswordGeneratedLength());
  365.                 if(serverProperties.isApplicativiBasicPasswordEnableConstraints()) {
  366.                     ControlStationCore.setApplicativiPasswordVerifierEngineApiMode(serverProperties.getApplicativiPasswordVerifier());
  367.                 }
  368.                 
  369.                 ControlStationCore.setSoggettiPasswordEncryptEngineApiMode(serverProperties.getSoggettiCryptConfig());
  370.                 ControlStationCore.setSoggettiApiKeyPasswordGeneratedLengthApiMode(serverProperties.getSoggettiApiKeyPasswordGeneratedLength());
  371.                 if(serverProperties.isSoggettiBasicPasswordEnableConstraints()) {
  372.                     ControlStationCore.setSoggettiPasswordVerifierEngineApiMode(serverProperties.getSoggettiPasswordVerifier());
  373.                 }
  374.                 
  375.                 Properties yamlSnakeLimits = serverProperties.getApiYamlSnakeLimits();
  376.                 if(yamlSnakeLimits!=null && !yamlSnakeLimits.isEmpty()) {
  377.                     YamlSnakeLimits.initialize(Startup.log, yamlSnakeLimits);
  378.                 }
  379.                 
  380.                 ControlStationCore.setIsSoggettiApplicativiCredenzialiBasicPermitSameCredentialsApiMode(serverProperties.isSoggettiApplicativiCredenzialiBasicPermitSameCredentials());
  381.                 ControlStationCore.setIsSoggettiApplicativiCredenzialiSslPermitSameCredentialsApiMode(serverProperties.isSoggettiApplicativiCredenzialiSslPermitSameCredentials());
  382.                 ControlStationCore.setIsSoggettiApplicativiCredenzialiPrincipalPermitSameCredentialsApiMode(serverProperties.isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials());
  383.                 
  384.                 DBUtils.setKeystoreJksPasswordRequired(serverProperties.isKeystoreJksPasswordRequired());
  385.                 DBUtils.setKeystoreJksKeyPasswordRequired(serverProperties.isKeystoreJksKeyPasswordRequired());
  386.                 DBUtils.setKeystorePkcs12PasswordRequired(serverProperties.isKeystorePkcs12PasswordRequired());
  387.                 DBUtils.setKeystorePkcs12KeyPasswordRequired(serverProperties.isKeystorePkcs12KeyPasswordRequired());
  388.                 DBUtils.setTruststoreJksPasswordRequired(serverProperties.isTruststoreJksPasswordRequired());
  389.                 DBUtils.setTruststorePkcs12PasswordRequired(serverProperties.isTruststorePkcs12PasswordRequired());
  390.                 
  391.                 // Inizializzazione SignalHub
  392.                 if(ProtocolFactoryManager.getInstance().existsProtocolFactory(org.openspcoop2.protocol.engine.constants.Costanti.MODIPA_PROTOCOL_NAME)) {
  393.                     CostantiDB.setServiziDigestEnabled(ModIUtils.isSignalHubEnabled());
  394.                 }
  395.                 
  396.             } catch (Exception e) {
  397.                 throw new UtilsRuntimeException(e.getMessage(),e);
  398.             }
  399.             Startup.log.info("Inizializzazione Risorse Statiche Console effettuata con successo");
  400.             
  401.             Startup.log.info("Inizializzazione Connettori in corso...");
  402.             try{
  403.                 Connettori.initialize(log, true, confDir, ServerProperties.getInstance().getProtocolloDefault());
  404.             }catch(Exception e){
  405.                 throw new UtilsRuntimeException(e.getMessage(),e);
  406.             }
  407.             Startup.log.info("Inizializzazione Connettori effettuata con successo");
  408.             
  409.             // Allarmi
  410.             try {
  411.                 if(ServerProperties.getInstance().isConfigurazioneAllarmiEnabled()!=null && ServerProperties.getInstance().isConfigurazioneAllarmiEnabled().booleanValue()) {
  412.                     Startup.log.info("Inizializzazione Allarmi in corso...");
  413.                     AlarmEngineConfig alarmEngineConfig = AlarmConfigProperties.getAlarmConfiguration(log, ServerProperties.getInstance().getAllarmiConfigurazione(), ServerProperties.getInstance().getConfDirectory());
  414.                     AlarmManager.setAlarmEngineConfig(alarmEngineConfig);
  415.                     CostantiDB.setAllarmiEnabled(true);
  416.                     Startup.log.info("Inizializzazione Allarmi effettuata con successo");
  417.                 }
  418.             } catch (Exception e) {
  419.                 doError("Errore durante l'inizializzazione degli allarmi",e);
  420.             }
  421.                 
  422.             // InitRuntimeConfigReader
  423.             if(reInitSecretMaps) {
  424.                 try{
  425.                     initRuntimeConfigReader = new InitRuntimeConfigReader(serverProperties, ConfigurazioneNodiRuntime.getConfigurazioneNodiRuntime(), reInitSecretMaps);
  426.                     initRuntimeConfigReader.start();
  427.                     Startup.log.info("RuntimeConfigReader avviato con successo.");
  428.                 } catch (Exception e) {
  429.                     /**doError("Errore durante l'inizializzazione del RuntimeConfigReader",e);*/
  430.                     // non sollevo l'eccezione, e' solo una informazione informativa, non voglio mettere un vincolo che serve per forza un nodo acceso
  431.                     Startup.log.error("Errore durante l'inizializzazione del RuntimeConfigReader: "+e.getMessage(),e);
  432.                 }
  433.             }
  434.             
  435.             Startup.initializedResources = true;
  436.             
  437.             Startup.log.info("Inizializzazione rs api config effettuata con successo.");
  438.         }
  439.     }

  441.     private static void doError(String msg,Exception e) {
  442.         String msgErrore = msg+": " + e.getMessage();
  443.         Startup.log.error(msgErrore,e);
  444.         throw new UtilsRuntimeException(msgErrore,e);
  445.     }
  446. }
Created with JaCoCo 0.8.8.202204050719