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

  21. package org.openspcoop2.pdd.config.loader.cli;

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

  32. import javax.naming.Context;
  33. import javax.naming.InitialContext;
  34. import javax.naming.NamingException;
  35. import javax.sql.DataSource;

  37. import org.apache.commons.lang.StringUtils;
  38. import org.openspcoop2.core.commons.CoreException;
  39. import org.openspcoop2.core.config.driver.ExtendedInfoManager;
  40. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  41. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  42. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  43. import org.openspcoop2.monitor.engine.dynamic.CorePluginLoader;
  44. import org.openspcoop2.monitor.engine.dynamic.PluginLoader;
  45. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  46. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  47. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  48. import org.openspcoop2.pdd.services.ServicesUtils;
  49. import org.openspcoop2.protocol.basic.registry.ConfigIntegrationReader;
  50. import org.openspcoop2.protocol.basic.registry.RegistryReader;
  51. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  52. import org.openspcoop2.protocol.engine.archive.ArchiveValidator;
  53. import org.openspcoop2.protocol.engine.archive.DeleterArchiveUtils;
  54. import org.openspcoop2.protocol.engine.archive.ImportInformationMissingCollection;
  55. import org.openspcoop2.protocol.engine.archive.ImporterArchiveUtils;
  56. import org.openspcoop2.protocol.sdk.ConfigurazionePdD;
  57. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  58. import org.openspcoop2.protocol.sdk.archive.Archive;
  59. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoDelete;
  60. import org.openspcoop2.protocol.sdk.archive.ArchiveEsitoImport;
  61. import org.openspcoop2.protocol.sdk.archive.ArchiveMode;
  62. import org.openspcoop2.protocol.sdk.archive.ArchiveModeType;
  63. import org.openspcoop2.protocol.sdk.archive.IArchive;
  64. import org.openspcoop2.protocol.sdk.archive.MapPlaceholder;
  65. import org.openspcoop2.utils.LoggerWrapperFactory;
  66. import org.openspcoop2.utils.certificate.byok.BYOKManager;
  67. import org.openspcoop2.utils.certificate.hsm.HSMManager;
  68. import org.openspcoop2.utils.certificate.hsm.HSMUtils;
  69. import org.openspcoop2.utils.crypt.CryptConfig;
  70. import org.openspcoop2.utils.crypt.PasswordVerifier;
  71. import org.openspcoop2.utils.properties.MapProperties;
  72. import org.openspcoop2.utils.resources.FileSystemUtilities;
  73. import org.openspcoop2.utils.security.ProviderUtils;
  74. import org.openspcoop2.web.ctrlstat.core.Connettori;
  75. import org.openspcoop2.web.ctrlstat.core.ControlStationCore;
  76. import org.openspcoop2.web.ctrlstat.core.DBManager;
  77. import org.openspcoop2.web.ctrlstat.driver.DriverControlStationDB;
  78. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiveEngine;
  79. import org.openspcoop2.web.ctrlstat.servlet.archivi.ArchiviCore;
  80. import org.slf4j.Logger;
  81. import org.springframework.jdbc.datasource.SingleConnectionDataSource;

  83. /**
  84.  *  Loader
  85.  *
  86.  * @author Poli Andrea (apoli@link.it)
  87.  * @author $Author$
  88.  * @version $Rev$, $Date$
  89.  */
  90. public class Loader {

  92.     private static Logger logCore = LoggerWrapperFactory.getLogger(Loader.class);
  93.     private static void logCoreDebug(String msg) {
  94.         logCore.debug(msg);
  95.     }
  96.     private static void logCoreInfo(String msg) {
  97.         logCore.info(msg);
  98.     }
  99.     private static void logCoreError(String msg, Exception e) {
  100.         logCore.error(msg,e);
  101.     }
  102.     private static Logger logSql = LoggerWrapperFactory.getLogger(Loader.class);
  103.     
  104.     private static boolean delete = false;
  105.     private static boolean updateAbilitato = true;
  106.     
  107.     private static ArchiveMode mode = org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_ARCHIVE_MODE;
  108.         
  109.     public static final String DS_JNDI_NAME = "org.govway.datasource.console";
  110.     
  111.     public static void main(String[] args) throws CoreException, SQLException {
  112.         
  113.         Connection connectionSQL = null;
  114.         try {
  115.         
  116.             // Logger
  117.             initLogger();
  118.             logCore=LoggerWrapperFactory.getLogger("config_loader.core");   
  119.             logSql=LoggerWrapperFactory.getLogger("config_loader.sql"); 
  120.             
  121.             
  122.             logCoreDebug("Raccolta parametri in corso...");
  123.             
  124.             // costanti
  125.             ArchiveModeType modeType = org.openspcoop2.protocol.basic.Costanti.OPENSPCOOP_ARCHIVE_MODE_TYPE;
  126.             boolean validateDocuments = true;
  127.             MapPlaceholder importInformationMissingGlobalPlaceholder = new MapPlaceholder();
  128.             boolean showCorrelazioneAsincronaInAccordi = true;
  129.             boolean smista = false;
  130.             
  131.             // properties
  132.             LoaderProperties loaderProperties = LoaderProperties.getInstance();
  133.             String confDir = null; // non sembra servire
  134.             String protocolloDefault = loaderProperties.getProtocolloDefault();
  135.             String userLogin = loaderProperties.getUtente();
  136.             

  138.             
  139.             // args
  140.             String utilizzoErrato = "Usage error: Loader <operationType> <archivePath>";
  141.             if(args.length<2 || args[0]==null || args[1]==null) {
  142.                 throw new CoreException(utilizzoErrato);
  143.             }
  144.             LoaderOperationType opType = parseOperationType(utilizzoErrato, args);
  145.             switch (opType) {
  146.             case CREATE:
  147.                 delete=false;
  148.                 updateAbilitato = false;
  149.                 break;
  150.             case CREATE_UPDATE:
  151.                 delete=false;
  152.                 updateAbilitato = true;
  153.                 break;
  154.             case DELETE:
  155.                 delete=true;
  156.                 updateAbilitato = false;
  157.                 break;
  158.             }
  159.             
  160.             String filePath = args[1].trim();
  161.             File fFilePath = new File(filePath);
  162.             String prefix = "L'archivio indicato ("+fFilePath.getAbsolutePath()+") ";
  163.             if(!fFilePath.exists()) {
  164.                 throw new CoreException(prefix+"non esiste");
  165.             }
  166.             if(!fFilePath.canRead()) {
  167.                 throw new CoreException(prefix+"non è accessibile");
  168.             }
  169.             if(!fFilePath.isFile()) {
  170.                 throw new CoreException(prefix+"non è un file");
  171.             }
  172.             byte [] archiveFile = FileSystemUtilities.readBytesFromFile(fFilePath);
  173.             
  174.             logCoreDebug("Raccolta parametri terminata");
  175.             
  176.             // Inizializzo Controlli connessioni
  177.             disableCheckSingleConnectionDataSource();
  178.             
  179.             // Map (environment)
  180.             initMap(loaderProperties);
  181.             
  182.             // Load Security Provider
  183.             if(loaderProperties.isSecurityLoadBouncyCastleProvider()) {
  184.                 initBouncyCastle();
  185.             }
  186.             
  187.             // inizializzo HSM Manager
  188.             initHsm(loaderProperties);
  189.             
  190.             // inizializzo BYOK Manager
  191.             BYOKManager byokManager = initBYOK(loaderProperties);
  192.             
  193.             // Secrets (environment)
  194.             initSecrets(loaderProperties, byokManager);
  195.             
  196.             
  197.             logCoreDebug("Inizializzazione connessione database in corso...");
  198.             
  199.             LoaderDatabaseProperties databaseProperties = LoaderDatabaseProperties.getInstance();
  200.             String tipoDatabase = databaseProperties.getTipoDatabase();
  201.             String driver = databaseProperties.getDriver();
  202.             String username = databaseProperties.getUsername();
  203.             String password = databaseProperties.getPassword();
  204.             String connectionURL = databaseProperties.getConnectionUrl();

  206.             org.openspcoop2.utils.resources.Loader.getInstance().newInstance(driver);
  207.             if(username!=null && password!=null){
  208.                 connectionSQL = DriverManager.getConnection(connectionURL,username,password);
  209.             }else{
  210.                 connectionSQL = DriverManager.getConnection(connectionURL);
  211.             }
  212.             
  213.             DataSource ds = new SingleConnectionDataSource(connectionSQL, true); 
  214.             System.setProperty(Context.INITIAL_CONTEXT_FACTORY, "org.apache.naming.java.javaURLContextFactory");
  215.             System.setProperty(Context.URL_PKG_PREFIXES, "org.apache.naming");
  216.             bindDatasource(ds, DS_JNDI_NAME);
  217.             
  218.             logCoreDebug("Inizializzazione connessione database terminata");
  219.             
  220.             
  221.             
  222.             logCoreDebug("Inizializzazione risorse libreria in corso...");
  223.             
  224.             ConfigurazionePdD configPdD = initProtocolFactory(protocolloDefault);
  225.             
  226.             initExtendedInfoManager();
  227.             
  228.             initCorePluginLoader(configPdD, loaderProperties, databaseProperties);
  229.             
  230.             Properties p = new Properties();
  231.             p.put("dataSource", DS_JNDI_NAME);
  232.             p.put("tipoDatabase", tipoDatabase);
  233.             if(!org.openspcoop2.web.ctrlstat.config.DatasourceProperties.initialize(p,logCore)){
  234.                 throw new CoreException("Inizializzazione fallita");
  235.             }
  236.         
  237.             initUtenze(loaderProperties);
  238.             
  239.             initConnettori(confDir, protocolloDefault);
  240.                         
  241.             logCoreDebug("Inizializzazione risorse libreria terminata");

  243.             

  245.             logCoreDebug("Inizializzazione driver ...");
  246.             
  247.             // istanzio il driver
  248.             DriverConfigurazioneDB driverConfigDB = new DriverConfigurazioneDB(connectionSQL, logSql, tipoDatabase);
  249.             DriverRegistroServiziDB driverRegistroDB = new DriverRegistroServiziDB(connectionSQL, logSql,tipoDatabase);
  250.                         
  251.             // Reader
  252.             RegistryReader registryReader = new RegistryReader(driverRegistroDB,logSql);
  253.             ConfigIntegrationReader configReader = new ConfigIntegrationReader(driverConfigDB,logSql);
  254.                         
  255.             // istanzio driver per Plugins
  256.             ServiceManagerProperties propertiesPlugins = new ServiceManagerProperties();
  257.             propertiesPlugins.setDatabaseType(tipoDatabase);
  258.             propertiesPlugins.setShowSql(true);
  259.             org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager jdbcServiceManagerPlugins = 
  260.                     new org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager(connectionSQL, propertiesPlugins, logSql);
  261.             
  262.             // istanzio driver per ControlloTraffico
  263.             ServiceManagerProperties propertiesControlloTraffico = new ServiceManagerProperties();
  264.             propertiesControlloTraffico.setDatabaseType(tipoDatabase);
  265.             propertiesControlloTraffico.setShowSql(true);
  266.             org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager jdbcServiceManagerControlloTraffico = 
  267.                     new org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager(connectionSQL, propertiesControlloTraffico, logSql);
  268.             
  269.             // istanzio driver per Allarmi
  270.             ServiceManagerProperties propertiesAllarmi = new ServiceManagerProperties();
  271.             propertiesAllarmi.setDatabaseType(tipoDatabase);
  272.             propertiesAllarmi.setShowSql(true);
  273.             org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager jdbcServiceManagerAllarmi = 
  274.                     new org.openspcoop2.core.allarmi.dao.jdbc.JDBCServiceManager(connectionSQL, propertiesAllarmi, logSql);
  275.             
  276.             // Istanzio ArchiviEngineControlStation
  277.             ControlStationCore core = new ControlStationCore(true, null, protocolloDefault);
  278.             ArchiviCore archiviCore = new ArchiviCore(core);
  279.             ArchiveEngine importerEngine = new ArchiveEngine(driverRegistroDB, 
  280.                     driverConfigDB,
  281.                     jdbcServiceManagerPlugins,
  282.                     jdbcServiceManagerControlloTraffico,
  283.                     jdbcServiceManagerAllarmi,
  284.                     archiviCore, smista, userLogin);
  285.             
  286.             logCoreDebug("Inizializzazione driver terminata");
  287.             
  288.             logCoreInfo("Inizializzazione engine terminata");           
  289.             
  290.             
  291.             
  292.             // parsing
  293.             logCoreInfo("Lettura archivio ...");
  294.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByName(protocolloDefault);
  295.             IArchive archiveEngine = pf.createArchive();
  296.             Archive archive = archiveEngine.importArchive(archiveFile, mode, modeType, registryReader, configReader,
  297.                     validateDocuments, importInformationMissingGlobalPlaceholder);
  298.             logCoreInfo("Lettura archivio effettuata");
  299.             
  300.             
  301.             // validate
  302.             logCoreInfo("Validazione archivio ...");
  303.             ArchiveValidator validator = new ArchiveValidator(registryReader);
  304.             ImportInformationMissingCollection importInformationMissingCollection = new ImportInformationMissingCollection();
  305.             validator.validateArchive(archive, protocolloDefault, validateDocuments, importInformationMissingCollection, userLogin, 
  306.                     showCorrelazioneAsincronaInAccordi,delete);
  307.             logCoreInfo("Validazione archivio effettuata");
  308.             
  309.             // finalize
  310.             logCoreInfo("Finalizzazione archivio ...");
  311.             archiveEngine.finalizeImportArchive(archive, mode, modeType, registryReader, configReader,
  312.                     validateDocuments, importInformationMissingGlobalPlaceholder);
  313.             logCoreInfo("Finalizzazione archivio effettuata");
  314.             
  315.             // store
  316.             process(importerEngine, userLogin, loaderProperties,
  317.                     archiveEngine, archive);        
  318.         }
  319.         catch(Exception t) {
  320.             if(logCore!=null) {
  321.                 logCore.error(t.getMessage(),t);
  322.             }
  323.             throw new CoreException(t.getMessage(),t);
  324.         }
  325.         finally {
  326.             if(connectionSQL!=null) {
  327.                 connectionSQL.close();
  328.             }
  329.         }

  331.     }
  332.     
  333.     private static void process(ArchiveEngine importerEngine, String userLogin, LoaderProperties loaderProperties,
  334.             IArchive archiveEngine, Archive archive) throws Exception {
  335.         
  336.         boolean importDeletePolicyConfig = loaderProperties.isPolicyEnable();
  337.         boolean importDeletePluginConfig = loaderProperties.isPluginEnable();
  338.         boolean importCheckPluginReferences = loaderProperties.isPluginCheckReferences();
  339.         boolean importConfig = loaderProperties.isConfigurazioneGeneraleEnable();
  340.         boolean isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto = loaderProperties.isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto();
  341.         boolean isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto = loaderProperties.isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto();
  342.         boolean isSoggettiApplicativiCredenzialiBasicPermitSameCredentials = loaderProperties.isSoggettiApplicativiCredenzialiBasicPermitSameCredentials();
  343.         boolean isSoggettiApplicativiCredenzialiSslPermitSameCredentials = loaderProperties.isSoggettiApplicativiCredenzialiSslPermitSameCredentials();
  344.         boolean isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials = loaderProperties.isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials();
  345.         
  346.         String importNomePddOperativa = loaderProperties.getNomePddOperativa();
  347.         String importTipoPddArchivi = loaderProperties.getTipoPddArchivio();
  348.                 
  349.         boolean isShowGestioneWorkflowStatoDocumenti = false;
  350.         boolean isShowAccordiColonnaAzioni = false;
  351.                 
  352.         String esito = null;
  353.         if(delete){
  354.             
  355.             logCoreInfo("Eliminazione in corso ...");
  356.             
  357.             DeleterArchiveUtils deleterArchiveUtils = 
  358.                     new DeleterArchiveUtils(importerEngine, logCore, userLogin,
  359.                             importDeletePolicyConfig,
  360.                             importDeletePluginConfig);
  361.             
  362.             ArchiveEsitoDelete esitoDelete = deleterArchiveUtils.deleteArchive(archive, userLogin);
  363.             
  364.             esito = archiveEngine.toString(esitoDelete, mode);
  365.             
  366.             logCoreInfo("Eliminazione completata");
  367.             
  368.         }else{
  369.             
  370.             logCoreInfo("Importazione (aggiornamento:"+updateAbilitato+") in corso ...");
  371.             
  372.             ImporterArchiveUtils importerArchiveUtils = 
  373.                     new ImporterArchiveUtils(importerEngine, logCore, userLogin, importNomePddOperativa, importTipoPddArchivi, 
  374.                             isShowGestioneWorkflowStatoDocumenti, updateAbilitato,
  375.                             importDeletePolicyConfig, 
  376.                             importDeletePluginConfig, importCheckPluginReferences,
  377.                             importConfig);
  378.             
  379.             ArchiveEsitoImport esitoImport = importerArchiveUtils.importArchive(archive, userLogin, 
  380.                     isShowAccordiColonnaAzioni,
  381.                     isAbilitatoControlloUnicitaImplementazioneAccordoPerSoggetto, 
  382.                     isAbilitatoControlloUnicitaImplementazionePortTypePerSoggetto,
  383.                     isSoggettiApplicativiCredenzialiBasicPermitSameCredentials,
  384.                     isSoggettiApplicativiCredenzialiSslPermitSameCredentials,
  385.                     isSoggettiApplicativiCredenzialiPrincipalPermitSameCredentials);
  386.             
  387.             esito = archiveEngine.toString(esitoImport, mode);
  388.             
  389.             logCoreInfo("Importazione (aggiornamento:"+updateAbilitato+") completata");
  390.         }
  391.         
  392.         logCoreInfo("Operazione terminata con esito:\n"+esito);

  394.     }

  396.     private static void initLogger() throws CoreException {
  397.         Properties propertiesLog4j = new Properties();
  398.         try (InputStream inPropLog4j = Loader.class.getResourceAsStream("/config_loader.cli.log4j2.properties");){
  399.             propertiesLog4j.load(inPropLog4j);
  400.             LoggerWrapperFactory.setLogConfiguration(propertiesLog4j);
  401.         } catch(java.lang.Exception e) {
  402.             throw new CoreException("Impossibile leggere i dati dal file 'config_loader.cli.log4j2.properties': "+e.getMessage());
  403.         } 
  404.     }
  405.     private static LoaderOperationType parseOperationType(String utilizzoErrato,String [] args) throws CoreException{
  406.         LoaderOperationType opType = null;
  407.         try {
  408.             opType = LoaderOperationType.toEnumConstant(args[0].trim(), true);
  409.         }catch(Exception e) {
  410.             throw new CoreException(utilizzoErrato+"\nIl tipo di operazione indicato ("+args[0].trim()+") non è gestito, valori ammessi: "+
  411.                     LoaderOperationType.CREATE.getValue()+","+LoaderOperationType.CREATE_UPDATE.getValue()+","+LoaderOperationType.DELETE.getValue());
  412.         }
  413.         return opType;
  414.     }
  415.     private static InitialContext bindDatasource(DataSource ds, String jndiName) throws NamingException {
  416.         InitialContext ic = new InitialContext();
  417.         try{
  418.             ic.bind(jndiName, ds);
  419.         }catch(javax.naming.NameAlreadyBoundException already){
  420.             logSql.debug("Bind failed: "+already.getMessage(),already);
  421.             //  capita in caso di più threads
  422.         }
  423.         
  424.         // Creazione su tomcat (per db audit appender)
  425.         boolean notFoundJava = false;
  426.         try {
  427.             ic.createSubcontext("java:");
  428.         }
  429.         catch (javax.naming.NameNotFoundException notFound) {
  430.             // il contesto java: non esiste
  431.             notFoundJava = true;
  432.             logSql.debug("CreateSubcontex java notFound: "+notFound.getMessage(),notFound);
  433.         }
  434.         catch (javax.naming.NameAlreadyBoundException already) {
  435.             logSql.debug("CreateSubcontext java failed: "+already.getMessage(),already);
  436.             // Il contesto esiste già, nessuna azione necessaria
  437.         }
  438.         try {
  439.             ic.createSubcontext("java:/comp");
  440.         }
  441.         catch (javax.naming.NameNotFoundException notFound) {
  442.             // il contesto java: non esiste
  443.             notFoundJava = true;
  444.             logSql.debug("CreateSubcontex comp notFound: "+notFound.getMessage(),notFound);
  445.         }
  446.         catch (javax.naming.NameAlreadyBoundException already) {
  447.             logSql.debug("CreateSubcontext comp failed: "+already.getMessage(),already);
  448.             // Il contesto esiste già, nessuna azione necessaria
  449.         }
  450.         try {
  451.             ic.createSubcontext("java:/comp/env");
  452.         }
  453.         catch (javax.naming.NameNotFoundException notFound) {
  454.             // il contesto java: non esiste
  455.             notFoundJava = true;
  456.             logSql.debug("CreateSubcontext comp/env notFound: "+notFound.getMessage(),notFound);
  457.         }
  458.         catch (javax.naming.NameAlreadyBoundException already) {
  459.             logSql.debug("CreateSubcontext comp/env failed: "+already.getMessage(),already);
  460.             // Il contesto esiste già, nessuna azione necessaria
  461.         }
  462.         if(!notFoundJava) {
  463.             try {
  464.                 ic.bind("java:/comp/env/"+jndiName, ds);
  465.             } catch (javax.naming.NameAlreadyBoundException already) {
  466.                 logSql.debug("Bind comp failed: "+already.getMessage(),already);
  467.                 // capita in caso di più threads
  468.             }
  469.         }
  470.         
  471.         return ic;
  472.     }
  473.     private static void initBouncyCastle() throws CoreException {
  474.         try{
  475.             ProviderUtils.addBouncyCastleAfterSun(true);
  476.             logCoreInfo("Aggiunto Security Provider org.bouncycastle.jce.provider.BouncyCastleProvider");
  477.         }catch(Exception e){
  478.             throw new CoreException(e.getMessage(),e);
  479.         }
  480.     }
  481.     private static void disableCheckSingleConnectionDataSource() throws CoreException {
  482.         // Inizializzo Controlli connessioni
  483.         try {
  484.             Logger logR = logSql;
  485.             ServicesUtils.initCheckConnectionDB(logR, false, false);
  486.             
  487.             DriverControlStationDB.setCheckLogger(logR);
  488.             DriverControlStationDB.setCheckIsClosed(false);
  489.             DriverControlStationDB.setCheckAutocommit(false);
  490.             DBManager.setCheckLogger(logR);
  491.             DBManager.setCheckIsClosed(false);
  492.             DBManager.setCheckAutocommit(false);
  493.         } catch (Exception e) {
  494.             doError("Inizializzazione controlli connessione non riuscita",e);
  495.         }
  496.     }
  497.     private static void initMap(LoaderProperties loaderProperties) throws CoreException {
  498.         try {
  499.             String mapConfig = loaderProperties.getEnvMapConfig();
  500.             if(StringUtils.isNotEmpty(mapConfig)) {
  501.                 logCoreInfo("Inizializzazione environment in corso...");
  502.                 MapProperties.initialize(logCore, mapConfig, loaderProperties.isEnvMapConfigRequired());
  503.                 MapProperties mapProperties = MapProperties.getInstance();
  504.                 mapProperties.initEnvironment();
  505.                 String msgInit = "Environment inizializzato con le variabili definite nel file '"+mapConfig+"'"+
  506.                         "\n\tJavaProperties: "+mapProperties.getJavaMap().keys()+
  507.                         "\n\tEnvProperties: "+mapProperties.getEnvMap().keys()+
  508.                         "\n\tObfuscateMode: "+mapProperties.getObfuscateModeDescription()+
  509.                         "\n\tObfuscatedJavaKeys: "+mapProperties.getObfuscatedJavaKeys()+
  510.                         "\n\tObfuscatedEnvKeys: "+mapProperties.getObfuscatedEnvKeys();
  511.                 logCoreInfo(msgInit);
  512.             }
  513.         } catch (Exception e) {
  514.             doError("Errore durante l'inizializzazione dell'ambiente",e);
  515.         }
  516.     }
  517.     private static void initHsm(LoaderProperties loaderProperties) throws CoreException {
  518.         // inizializzo HSM Manager
  519.         try {
  520.             String hsmConfig = loaderProperties.getHSMConfigurazione();
  521.             if(StringUtils.isNotEmpty(hsmConfig)) {
  522.                 logCoreInfo("Inizializzazione HSM in corso...");
  523.                 File f = new File(hsmConfig);
  524.                 HSMManager.init(f, loaderProperties.isHSMRequired(), logCore, false);
  525.                 HSMUtils.setHsmConfigurableKeyPassword(loaderProperties.isHSMKeyPasswordConfigurable());
  526.                 logCoreInfo("Inizializzazione HSM effettuata con successo");
  527.             }
  528.         } catch (Exception e) {
  529.             doError("Errore durante l'inizializzazione del manager HSM",e);
  530.         }
  531.     }
  532.     private static BYOKManager initBYOK(LoaderProperties loaderProperties) throws CoreException {
  533.         BYOKManager byokManager = null;
  534.         try {
  535.             String byokConfig = loaderProperties.getBYOKConfigurazione();
  536.             if(StringUtils.isNotEmpty(byokConfig)) {
  537.                 logCoreInfo("Inizializzazione BYOK in corso...");
  538.                 File f = new File(byokConfig);
  539.                 BYOKManager.init(f, loaderProperties.isBYOKRequired(), logCore);
  540.                 byokManager = BYOKManager.getInstance();
  541.                 String msgInit = "Gestore BYOK inizializzato;"+
  542.                         "\n\tHSM registrati: "+byokManager.getKeystoreTypes()+
  543.                         "\n\tSecurityEngine registrati: "+byokManager.getSecurityEngineTypes()+
  544.                         "\n\tGovWaySecurityEngine: "+byokManager.getSecurityEngineGovWayDescription();
  545.                 logCoreInfo(msgInit);
  546.             }
  547.         } catch (Exception e) {
  548.             doError("Errore durante l'inizializzazione del manager BYOK",e);
  549.         }
  550.         return byokManager;
  551.     }
  552.     private static void initSecrets(LoaderProperties loaderProperties, BYOKManager byokManager) throws CoreException {
  553.         try {
  554.             String secretsConfig = loaderProperties.getBYOKEnvSecretsConfig();
  555.             if(byokManager!=null && StringUtils.isNotEmpty(secretsConfig)) {
  556.                 logCoreInfo("Inizializzazione secrets in corso...");
  557.                 
  558.                 Map<String, Object> dynamicMap = new HashMap<>();
  559.                 DynamicInfo dynamicInfo = new  DynamicInfo();
  560.                 DynamicUtils.fillDynamicMap(logCore, dynamicMap, dynamicInfo);
  561.                 
  562.                 BYOKMapProperties.initialize(logCore, secretsConfig, loaderProperties.isBYOKEnvSecretsConfigRequired(), 
  563.                         true, 
  564.                         dynamicMap, true);
  565.                 BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  566.                 secretsProperties.initEnvironment();
  567.                 String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"'"+
  568.                         "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  569.                         "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  570.                         "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription();
  571.                 logCoreInfo(msgInit);
  572.             }
  573.         } catch (Exception e) {
  574.             doError("Errore durante l'inizializzazione dell'ambiente (secrets)",e);
  575.         }   
  576.     }
  577.     private static ConfigurazionePdD initProtocolFactory(String protocolloDefault) throws CoreException {
  578.         ConfigurazionePdD configPdD = null;
  579.         try {
  580.             configPdD = new ConfigurazionePdD();
  581.             configPdD.setAttesaAttivaJDBC(-1);
  582.             configPdD.setCheckIntervalJDBC(-1);
  583.             configPdD.setLoader(new org.openspcoop2.utils.resources.Loader(Loader.class.getClassLoader()));
  584.             configPdD.setLog(logCore);
  585.             ProtocolFactoryManager.initialize(logCore, configPdD,
  586.                     protocolloDefault);
  587.         } catch (Exception e) {
  588.             throw new CoreException("Errore (InitConfigurazione - ProtocolFactoryManager): "+e.getMessage(),e);
  589.         }
  590.         return configPdD;
  591.     }
  592.     private static void initExtendedInfoManager() throws CoreException {
  593.         try{
  594.             ExtendedInfoManager.initialize(new org.openspcoop2.utils.resources.Loader(Loader.class.getClassLoader()), null, null, null);
  595.         }catch(Exception e){
  596.             throw new CoreException("Inizializzazione [ExtendedInfoManager] fallita",e);
  597.         }
  598.     }
  599.     private static void initCorePluginLoader(ConfigurazionePdD configPdD, LoaderProperties loaderProperties, LoaderDatabaseProperties databaseProperties) throws CoreException {
  600.         try{
  601.             CorePluginLoader.initialize(configPdD.getLoader(), logSql,
  602.                     PluginLoader.class,
  603.                     new LoaderRegistroPluginsService(logSql, databaseProperties),
  604.                     loaderProperties.getPluginSeconds());
  605.         }catch(Exception e){
  606.             throw new CoreException("Inizializzazione [PluginManager] fallita",e);
  607.         }
  608.     }
  609.     private static void initUtenze(LoaderProperties loaderProperties) throws CoreException {
  610.         try {
  611.             CryptConfig utenzeCryptConfig = new CryptConfig(loaderProperties.getUtenzePassword());
  612.             CryptConfig applicativiCryptConfig = new CryptConfig(loaderProperties.getApplicativiPassword());
  613.             int applicativiApiKeyPasswordGeneratedLength=loaderProperties.getApplicativiApiKeyPasswordGeneratedLength();
  614.             boolean applicativiBasicPasswordEnableConstraints=loaderProperties.isApplicativiBasicPasswordEnableConstraints();
  615.             CryptConfig soggettiCryptConfig = new CryptConfig(loaderProperties.getSoggettiPassword());
  616.             int soggettiApiKeyPasswordGeneratedLength=loaderProperties.getSoggettiApiKeyPasswordGeneratedLength();
  617.             boolean soggettiBasicPasswordEnableConstraints=loaderProperties.isSoggettiBasicPasswordEnableConstraints();
  618.             
  619.             ControlStationCore.setUtenzePasswordEncryptEngineApiMode(utenzeCryptConfig);
  620.             
  621.             ControlStationCore.setApplicativiPasswordEncryptEngineApiMode(applicativiCryptConfig);
  622.             ControlStationCore.setApplicativiApiKeyPasswordGeneratedLengthApiMode(applicativiApiKeyPasswordGeneratedLength);
  623.             if(applicativiBasicPasswordEnableConstraints) {
  624.                 PasswordVerifier applicativiPasswordVerifier = new PasswordVerifier("/org/openspcoop2/utils/crypt/consolePassword.properties");
  625.                 ControlStationCore.setApplicativiPasswordVerifierEngineApiMode(applicativiPasswordVerifier);
  626.             }
  627.             
  628.             ControlStationCore.setSoggettiPasswordEncryptEngineApiMode(soggettiCryptConfig);
  629.             ControlStationCore.setSoggettiApiKeyPasswordGeneratedLengthApiMode(soggettiApiKeyPasswordGeneratedLength);
  630.             if(soggettiBasicPasswordEnableConstraints) {
  631.                 PasswordVerifier soggettiPasswordVerifier = new PasswordVerifier("/org/openspcoop2/utils/crypt/consolePassword.properties");
  632.                 ControlStationCore.setSoggettiPasswordVerifierEngineApiMode(soggettiPasswordVerifier);
  633.             }
  634.             
  635.         } catch (Exception e) {
  636.             throw new CoreException(e.getMessage(),e);
  637.         }
  638.     }
  639.     private static void initConnettori(String confDir, String protocolloDefault) throws CoreException {
  640.         try{
  641.             Connettori.initialize(logCore, true, confDir, protocolloDefault);
  642.         }catch(Exception e){
  643.             throw new CoreException(e.getMessage(),e);
  644.         }
  645.     }

  647.     private static void doError(String msg,Exception e) throws CoreException {
  648.         String msgErrore = msg+": " + e.getMessage();
  649.         logCoreError(msgErrore,e);
  650.         throw new CoreException(msgErrore,e);
  651.     }
  652. }
Created with JaCoCo 0.8.8.202204050719