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.config.driver.ExtendedInfoManager;
  35. import org.openspcoop2.core.constants.CostantiDB;
  36. import org.openspcoop2.monitor.engine.alarm.AlarmConfigProperties;
  37. import org.openspcoop2.monitor.engine.alarm.AlarmEngineConfig;
  38. import org.openspcoop2.monitor.engine.alarm.AlarmManager;
  39. import org.openspcoop2.pdd.config.ConfigurazioneNodiRuntime;
  40. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  41. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  42. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  43. import org.openspcoop2.pdd.services.ServicesUtils;
  44. import org.openspcoop2.utils.LoggerWrapperFactory;
  45. import org.openspcoop2.utils.UtilsRuntimeException;
  46. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  47. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  48. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  49. import org.openspcoop2.utils.certificate.ocsp.OCSPManager;
  50. import org.openspcoop2.utils.json.YamlSnakeLimits;
  51. import org.openspcoop2.utils.properties.MapProperties;
  52. import org.openspcoop2.utils.resources.Loader;
  53. import org.openspcoop2.utils.security.ProviderUtils;
  54. import org.openspcoop2.web.ctrlstat.core.Connettori;
  55. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  56. import org.openspcoop2.web.ctrlstat.core.DBManager;
  57. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  58. import org.openspcoop2.web.ctrlstat.servlet.ConsoleHelper;
  59. import org.openspcoop2.web.lib.users.dao.InterfaceType;
  60. import org.slf4j.Logger;
  61. /**
  62.  * Questa classe si occupa di inizializzare tutte le risorse necessarie al webService.
  63.  * 
  64.  * 
  65.  * @author Andrea Poli (apoli@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  * 
  69.  */

  71. public class Startup implements ServletContextListener {

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

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

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

  92.     }

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

  101.     }
  102.     

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

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

  136.         }catch(Exception e){
  137.             // ignore
  138.         }
  139.         
  140.         if(!Startup.initializedLog){
  141.             
  142.             try{
  143.                 Startup.log = LoggerWrapperFactory.getLogger(Startup.class);
  144.                 LoggerProperties.initialize(Startup.log, confDir, null);
  145.                 Startup.initializedLog = true;
  146.                 Startup.log = LoggerProperties.getLoggerCore();
  147.                 
  148.             }catch(Exception e){
  149.                 throw new UtilsRuntimeException(e.getMessage(),e);
  150.             }
  151.         }
  152.         
  153.         return confDir;
  154.     }
  155.     
  156.     
  157.     // RESOURCES
  158.     
  159.     private static boolean initializedResources = false;
  160.     
  161.     public static synchronized void initResources(){
  162.         if(!Startup.initializedResources){
  163.             
  164.             String confDir = Startup.initLog();
  165.             
  166.             Startup.log.info("Inizializzazione rs api config in corso...");
  167.             
  168.             if(!ServerProperties.initialize(confDir,Startup.log)){
  169.                 return;
  170.             }
  171.             ServerProperties serverProperties = null;
  172.             try {
  173.                 serverProperties = ServerProperties.getInstance();
  174.             } catch (Exception e) {
  175.                 doError("Errore durante l'inizializzazione del serverProperties",e);
  176.             }
  177.             
  178.             // Inizializzo Controlli connessioni
  179.             try {
  180.                 Logger logR = Startup.log;
  181.                 ServicesUtils.initCheckConnectionDB(logR, serverProperties.isJdbcCloseConnectionCheckIsClosed(), serverProperties.isJdbcCloseConnectionCheckAutocommit());
  182.                 
  183.                 DriverControlStationDB.setCheckLogger(logR);
  184.                 DriverControlStationDB.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  185.                 DriverControlStationDB.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  186.                 DBManager.setCheckLogger(logR);
  187.                 DBManager.setCheckIsClosed(serverProperties.isJdbcCloseConnectionCheckIsClosed());
  188.                 DBManager.setCheckAutocommit(serverProperties.isJdbcCloseConnectionCheckAutocommit());
  189.             } catch (Exception e) {
  190.                 doError("Inizializzazione controlli connessione non riuscita",e);
  191.             }
  192.             
  193.             // Map (environment)
  194.             try {
  195.                 String mapConfig = serverProperties.getEnvMapConfig();
  196.                 if(StringUtils.isNotEmpty(mapConfig)) {
  197.                     Startup.log.info("Inizializzazione environment in corso...");
  198.                     MapProperties.initialize(Startup.log, mapConfig, serverProperties.isEnvMapConfigRequired());
  199.                     MapProperties mapProperties = MapProperties.getInstance();
  200.                     mapProperties.initEnvironment();
  201.                     String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  202.                             "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  203.                             "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  204.                             "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  205.                             "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  206.                             "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  207.                     Startup.log.info(msgInit);
  208.                 }
  209.             } catch (Exception e) {
  210.                 doError("Errore durante l'inizializzazione dell'ambiente",e);
  211.             }
  212.             
  213.             // Load Security Provider
  214.             Startup.log.info("Inizializzazione security provider...");
  215.             try {
  216.                 if(serverProperties.isSecurityLoadBouncyCastleProvider()) {
  217.                     ProviderUtils.addBouncyCastleAfterSun(true);
  218.                     Startup.log.info("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  219.                 }
  220.             } catch (Exception e) {
  221.                 doError("Errore durante l'inizializzazione dei security provider",e);
  222.             }
  223.             Startup.log.info("Inizializzazione security provider effettuata con successo");
  224.             
  225.             // inizializzo HSM Manager
  226.             try {
  227.                 String hsmConfig = serverProperties.getHSMConfigurazione();
  228.                 if(StringUtils.isNotEmpty(hsmConfig)) {
  229.                     Startup.log.info("Inizializzazione HSM in corso...");
  230.                     File f = new File(hsmConfig);
  231.                     HSMManager.init(f, serverProperties.isHSMRequired(), log, false);
  232.                     HSMUtils.setHsmConfigurableKeyPassword(serverProperties.isHSMKeyPasswordConfigurable());
  233.                     Startup.log.info("Inizializzazione HSM effettuata con successo");
  234.                 }
  235.             } catch (Exception e) {
  236.                 doError("Errore durante l'inizializzazione del manager HSM",e);
  237.             }
  238.             
  239.             // inizializzo BYOK Manager
  240.             BYOKManager byokManager = null;
  241.             try {
  242.                 String byokConfig = serverProperties.getBYOKConfigurazione();
  243.                 if(StringUtils.isNotEmpty(byokConfig)) {
  244.                     Startup.log.info("Inizializzazione BYOK in corso...");
  245.                     File f = new File(byokConfig);
  246.                     BYOKManager.init(f, serverProperties.isBYOKRequired(), log);
  247.                     byokManager = BYOKManager.getInstance();
  248.                     String msgInit = "Gestore BYOK inizializzato;"+
  249.                             "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  250.                             "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  251.                             "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  252.                     Startup.log.info(msgInit);
  253.                 }
  254.             } catch (Exception e) {
  255.                 doError("Errore durante l'inizializzazione del manager BYOK",e);
  256.             }
  257.             
  258.             // inizializzo OCSP Manager
  259.             Startup.log.info("Inizializzazione OCSP in corso...");
  260.             try {
  261.                 String ocspConfig = serverProperties.getOCSPConfigurazione();
  262.                 if(StringUtils.isNotEmpty(ocspConfig)) {
  263.                     File f = new File(ocspConfig);
  264.                     OCSPManager.init(f, serverProperties.isOCSPRequired(), serverProperties.isOCSPLoadDefault(), log);
  265.                 }
  266.             } catch (Exception e) {
  267.                 doError("Errore durante l'inizializzazione del manager OCSP",e);
  268.             }
  269.             Startup.log.info("Inizializzazione OCSP effettuata con successo");
  270.             
  271.             // Secrets (environment)
  272.             boolean reInitSecretMaps = false;
  273.             try {
  274.                 String secretsConfig = serverProperties.getBYOKEnvSecretsConfig();
  275.                 if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  276.                     Startup.log.info("Inizializzazione secrets in corso...");

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

  407.     private static void doError(String msg,Exception e) {
  408.         String msgErrore = msg+": " + e.getMessage();
  409.         Startup.log.error(msgErrore,e);
  410.         throw new UtilsRuntimeException(msgErrore,e);
  411.     }
  412. }
Created with JaCoCo 0.8.8.202204050719