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.utils.LoggerWrapperFactory;
  46. import org.openspcoop2.utils.UtilsRuntimeException;
  47. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  48. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  49. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  50. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  51. import org.openspcoop2.utils.json.YamlSnakeLimits;
  52. import org.openspcoop2.utils.properties.MapProperties;
  53. import org.openspcoop2.utils.resources.Loader;
  54. import org.openspcoop2.utils.security.ProviderUtils;
  55. import org.openspcoop2.web.ctrlstat.core.Connettori;
  56. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  57. import org.openspcoop2.web.ctrlstat.core.DBManager;
  58. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  59. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  60. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  61. import org.slf4j.Logger;
  62. /**
  63.  * Questa classe si occupa di inizializzare tutte le risorse necessarie al webService.
  64.  * 
  65.  * 
  66.  * @author Andrea Poli (apoli@link.it)
  67.  * @author $Author$
  68.  * @version $Rev$, $Date$
  69.  * 
  70.  */

  72. public class Startup implements ServletContextListener {

  74.     private static Logger log = null;
  75.     public static Logger getLog() {
  76.         return log;
  77.     }

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

  86.          if(initRuntimeConfigReader!=null) {
  87.                 initRuntimeConfigReader.setStop(true);
  88.          }
  89.         
  90.         if(Startup.log!=null)
  91.             Startup.log.info("Undeploy webService effettuato.");

  93.     }

  95.     @Override
  96.     public void contextInitialized(ServletContextEvent sce) {
  97.         
  98.         Startup.initLog();
  99.         
  100.         Startup.initResources();

  102.     }
  103.     

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

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

  137.         }catch(Exception e){
  138.             // ignore
  139.         }
  140.         
  141.         if(!Startup.initializedLog){
  142.             
  143.             try{
  144.                 Startup.log = LoggerWrapperFactory.getLogger(Startup.class);
  145.                 LoggerProperties.initialize(Startup.log, confDir, null);
  146.                 Startup.initializedLog = true;
  147.                 Startup.log = LoggerProperties.getLoggerCore();
  148.                 
  149.             }catch(Exception e){
  150.                 throw new UtilsRuntimeException(e.getMessage(),e);
  151.             }
  152.         }
  153.         
  154.         return confDir;
  155.     }
  156.     
  157.     
  158.     // RESOURCES
  159.     
  160.     private static boolean initializedResources = false;
  161.     
  162.     public static synchronized void initResources(){
  163.         if(!Startup.initializedResources){
  164.             
  165.             String confDir = Startup.initLog();
  166.             
  167.             Startup.log.info("Inizializzazione rs api config in corso...");
  168.             
  169.             if(!ServerProperties.initialize(confDir,Startup.log)){
  170.                 return;
  171.             }
  172.             ServerProperties serverProperties = null;
  173.             try {
  174.                 serverProperties = ServerProperties.getInstance();
  175.             } catch (Exception e) {
  176.                 doError("Errore durante l'inizializzazione del serverProperties",e);
  177.             }
  178.             
  179.             // Inizializzo Controlli connessioni
  180.             try {
  181.                 Logger logR = Startup.log;
  182.                 ServicesUtils.initCheckConnectionDB(logR, serverProperties.isJdbcCloseConnectionCheckIsClosed(), serverProperties.isJdbcCloseConnectionCheckAutocommit());
  183.                 
  184.                 DriverControlStationDB.setCheckLogger(logR);
  185.                 DriverControlStationDB.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  186.                 DriverControlStationDB.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  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.             // inizializzo OCSP Manager
  260.             Startup.log.info("Inizializzazione OCSP in corso...");
  261.             try {
  262.                 String ocspConfig = serverProperties.getOCSPConfigurazione();
  263.                 if(StringUtils.isNotEmpty(ocspConfig)) {
  264.                     File f = new File(ocspConfig);
  265.                     OCSPManager.init(f, serverProperties.isOCSPRequired(), serverProperties.isOCSPLoadDefault(), log);
  266.                 }
  267.             } catch (Exception e) {
  268.                 doError("Errore durante l'inizializzazione del manager OCSP",e);
  269.             }
  270.             Startup.log.info("Inizializzazione OCSP effettuata con successo");
  271.             
  272.             // Secrets (environment)
  273.             boolean reInitSecretMaps = false;
  274.             try {
  275.                 String secretsConfig = serverProperties.getBYOKEnvSecretsConfig();
  276.                 if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  277.                     Startup.log.info("Inizializzazione secrets in corso...");

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

  415.     private static void doError(String msg,Exception e) {
  416.         String msgErrore = msg+": " + e.getMessage();
  417.         Startup.log.error(msgErrore,e);
  418.         throw new UtilsRuntimeException(msgErrore,e);
  419.     }
  420. }
Created with JaCoCo 0.8.8.202204050719