PreLoadingConfig.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;

  23. import java.io.ByteArrayOutputStream;
  24. import java.io.File;
  25. import java.io.IOException;
  26. import java.io.InputStream;
  27. import java.sql.Connection;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.Iterator;
  31. import java.util.List;
  32. import java.util.zip.ZipEntry;
  33. import java.util.zip.ZipFile;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.config.AccessoRegistro;
  37. import org.openspcoop2.core.config.AccessoRegistroRegistro;
  38. import org.openspcoop2.core.config.Configurazione;
  39. import org.openspcoop2.core.config.GenericProperties;
  40. import org.openspcoop2.core.config.InoltroBusteNonRiscontrate;
  41. import org.openspcoop2.core.config.MessaggiDiagnostici;
  42. import org.openspcoop2.core.config.Openspcoop2;
  43. import org.openspcoop2.core.config.PortaApplicativa;
  44. import org.openspcoop2.core.config.PortaDelegata;
  45. import org.openspcoop2.core.config.ServizioApplicativo;
  46. import org.openspcoop2.core.config.Soggetto;
  47. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  48. import org.openspcoop2.core.config.constants.RegistroTipo;
  49. import org.openspcoop2.core.config.constants.Severita;
  50. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  51. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  52. import org.openspcoop2.core.config.driver.db.DriverConfigurazioneDB;
  53. import org.openspcoop2.core.config.utils.CleanerOpenSPCoop2Extensions;
  54. import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
  55. import org.openspcoop2.core.controllo_traffico.IdPolicy;
  56. import org.openspcoop2.core.id.IDSoggetto;
  57. import org.openspcoop2.core.plugins.IdPlugin;
  58. import org.openspcoop2.core.registry.RegistroServizi;
  59. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  60. import org.openspcoop2.core.registry.constants.StatiAccordo;
  61. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  62. import org.openspcoop2.core.registry.driver.IDriverRegistroServiziGet;
  63. import org.openspcoop2.core.registry.driver.db.DriverRegistroServiziDB;
  64. import org.openspcoop2.generic_project.exception.NotImplementedException;
  65. import org.openspcoop2.generic_project.exception.ServiceException;
  66. import org.openspcoop2.generic_project.utils.ServiceManagerProperties;
  67. import org.openspcoop2.message.xml.MessageXMLUtils;
  68. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  69. import org.openspcoop2.protocol.engine.constants.Costanti;
  70. import org.openspcoop2.protocol.registry.RegistroServiziReader;
  71. import org.openspcoop2.protocol.sdk.ProtocolException;
  72. import org.openspcoop2.protocol.utils.ModIUtils;
  73. import org.openspcoop2.utils.Utilities;
  74. import org.openspcoop2.utils.UtilsException;
  75. import org.openspcoop2.utils.beans.WriteToSerializerType;
  76. import org.openspcoop2.utils.io.ZipUtilities;
  77. import org.openspcoop2.utils.regexp.RegExpException;
  78. import org.openspcoop2.utils.regexp.RegExpNotFoundException;
  79. import org.openspcoop2.utils.regexp.RegExpNotValidException;
  80. import org.openspcoop2.utils.regexp.RegularExpressionEngine;
  81. import org.openspcoop2.utils.resources.FileSystemUtilities;
  82. import org.slf4j.Logger;
  83. import org.w3c.dom.Element;

  85. /**
  86.  *  ZipConfigurationReader
  87.  *
  88.  * @author Poli Andrea (apoli@link.it)
  89.  * @author $Author$
  90.  * @version $Rev$, $Date$
  91.  */
  92. public class PreLoadingConfig  {

  94.     private static final String SOGGETTO_LOCALE = "@SOGGETTO_LOCALE@";
  95.     private static final String GOVWAY_ENTITY_NAME = "GOVWAY_DEFAULT_ENTITY_NAME";
  96.     private static final String VARIABLE_GOVWAY_ENTITY_NAME = "${"+GOVWAY_ENTITY_NAME+"}";
  97.     
  98.     private Logger log;
  99.     private Logger logDriver;
  100.     private String protocolloDefault;
  101.     private IDSoggetto dominio;
  102.     public PreLoadingConfig(Logger log, Logger logDriver, String protocolloDefault, IDSoggetto dominio) {
  103.         this.log = log;
  104.         this.logDriver = logDriver;
  105.         this.protocolloDefault = protocolloDefault;
  106.         this.dominio = dominio;
  107.     }

  109.     public Logger getLogDriver() {
  110.         return this.logDriver;
  111.     }
  112.     private void logInfo(String msg) {
  113.         if(this.log!=null) {
  114.             this.log.info(msg);
  115.         }
  116.     }
  117.     private void logError(String msg, Exception e) {
  118.         if(this.log!=null) {
  119.             this.log.error(msg,e);
  120.         }
  121.     }
  122.     
  123.     public void loadConfig(List<PreloadingConfiguration> zipContent) throws UtilsException, IOException, DriverConfigurazioneException, ServiceException, NotImplementedException, ProtocolException {
  124.         if(zipContent!=null && !zipContent.isEmpty()) {
  125.             for (PreloadingConfiguration bs : zipContent) {
  126.                 boolean load = true;
  127.                 if(bs.getName().contains("signalHubPDND") &&
  128.                     (
  129.                             !ProtocolFactoryManager.getInstance().existsProtocolFactory(Costanti.MODIPA_PROTOCOL_NAME) 
  130.                             ||
  131.                             !ModIUtils.isSignalHubEnabled())
  132.                         ){
  133.                     logInfo("Pacchetto '"+bs.getName()+"' non caricato; funzionalità 'Signal Hub' non attiva");
  134.                     load = false;
  135.                 }
  136.                 else if(bs.getName().contains("tracingPDND") &&
  137.                     (
  138.                             !ProtocolFactoryManager.getInstance().existsProtocolFactory(Costanti.MODIPA_PROTOCOL_NAME) 
  139.                             ||
  140.                             !ModIUtils.isTracingPDNDEnabled())
  141.                         ){
  142.                     logInfo("Pacchetto '"+bs.getName()+"' non caricato; funzionalità 'Tracing PDND' non attiva");
  143.                     load = false;
  144.                 }
  145.                 if(load) {
  146.                     this.loadConfig(bs.getResource());
  147.                 }
  148.             }
  149.         }
  150.     }
  151.     private void loadConfig(byte[] zipContent) throws UtilsException, IOException, DriverConfigurazioneException, ServiceException, NotImplementedException {
  152.         
  153.         List<String> pluginNameList = new ArrayList<>();
  154.         List<byte[]> pluginList = new ArrayList<>();
  155.         
  156.         List<String> configNameList = new ArrayList<>();
  157.         List<byte[]> configList = new ArrayList<>();
  158.         
  159.         List<String> registryNameList = new ArrayList<>();
  160.         List<byte[]> registryList = new ArrayList<>();
  161.         
  162.         List<String> controllaTrafficoConfigPolicyNameList = new ArrayList<>();
  163.         List<byte[]> controllaTrafficoConfigPolicyList = new ArrayList<>();
  164.         
  165.         List<String> controllaTrafficoActivePolicyNameList = new ArrayList<>();
  166.         List<byte[]> controllaTrafficoActivePolicyList = new ArrayList<>();
  167.         
  168.         HashMap<String, Document> contentList = new HashMap<>();
  169.         
  170.         File fTmp = FileSystemUtilities.createTempFile("preLoadConfiguration", ".zip");
  171.         /**System.out.println("TMP: "+fTmp.getAbsolutePath());*/
  172.         try {
  173.             FileSystemUtilities.writeFile(fTmp, zipContent);
  174.             ZipFile zip = new ZipFile(fTmp);
  175.             Iterator<ZipEntry> itZip = ZipUtilities.entries(zip, true);
  176.             while (itZip.hasNext()) {
  177.                 ZipEntry zipEntry = itZip.next();
  178.                 if(!zipEntry.isDirectory()) {
  179.                     InputStream isZip = zip.getInputStream(zipEntry);
  180.                     try {
  181.                         /**System.out.println("LEGGO ["+zipEntry.getName()+"]");*/
  182.                         byte [] bytes = Utilities.getAsByteArray(isZip);
  183.                         String sBytes = new String(bytes);
  184.                         if(sBytes.contains(SOGGETTO_LOCALE)) {
  185.                             while(sBytes.contains(SOGGETTO_LOCALE)) {
  186.                                 sBytes = sBytes.replace(SOGGETTO_LOCALE, this.dominio.getNome());
  187.                             }
  188.                             bytes = sBytes.getBytes();
  189.                         }
  190.                         if(sBytes.contains(VARIABLE_GOVWAY_ENTITY_NAME)) {
  191.                             String valueSystemProperty = convertVariabile(GOVWAY_ENTITY_NAME);
  192.                             if(valueSystemProperty==null || StringUtils.isEmpty(valueSystemProperty)) {
  193.                                 throw new ServiceException("Una configurazione creata con la variabile '"+VARIABLE_GOVWAY_ENTITY_NAME+"' richiede la sua definizione come variabile di sistema o java");
  194.                             }
  195.                         }
  196.                         String afterVariable = null;
  197.                         try {
  198.                             afterVariable = convertVariable(sBytes);
  199.                         }catch(Exception e) {
  200.                             throw new UtilsException(e.getMessage(),e);
  201.                         }
  202.                         if(afterVariable!=null && !afterVariable.equals(sBytes)) {
  203.                             bytes = afterVariable.getBytes();
  204.                         }
  205.                         try {
  206.                             
  207.                             String entryName = zipEntry.getName();
  208.                             int indexOfWsdl = -1;
  209.                             String name = null;
  210.                             if(entryName.endsWith(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL) ) {
  211.                                 indexOfWsdl = entryName.indexOf(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL);
  212.                                 name = CostantiRegistroServizi.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL;
  213.                             }
  214.                             else if(entryName.endsWith(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL) ) {
  215.                                 indexOfWsdl = entryName.indexOf(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL);
  216.                                 name = CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL;
  217.                             }
  218.                             else if(entryName.endsWith(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL) ) {
  219.                                 indexOfWsdl = entryName.indexOf(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL);
  220.                                 name = CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL;
  221.                             }
  222.                             if(indexOfWsdl>0) {
  223.                                 String prefixEntryName = entryName.substring(0, indexOfWsdl-1);
  224.                                 int posizione = 0; // default
  225.                                 if(prefixEntryName.contains(".") && !prefixEntryName.endsWith(".")) {
  226.                                     String posizioneEntry = prefixEntryName.substring(prefixEntryName.lastIndexOf(".")+1, prefixEntryName.length());
  227.                                     posizione = converPosizione(posizioneEntry);
  228.                                     prefixEntryName = prefixEntryName.substring(0, prefixEntryName.lastIndexOf("."));
  229.                                 }
  230.                                 Document d = new Document();
  231.                                 d.content = bytes;
  232.                                 d.index = posizione;
  233.                                 d.name = name;
  234.                                 contentList.put(prefixEntryName, d);
  235.                             }
  236.                             else {
  237.                             
  238.                                 Element element = MessageXMLUtils.DEFAULT.newElement(bytes);
  239.                                 if(org.openspcoop2.core.plugins.utils.XMLUtils.isPlugin(element)) {
  240.                                     pluginNameList.add(entryName);
  241.                                     pluginList.add(bytes);
  242.                                 }
  243.                                 else if(org.openspcoop2.core.config.utils.XMLUtils.isConfigurazione(element)) {
  244.                                     configNameList.add(entryName);
  245.                                     configList.add(bytes);
  246.                                 }
  247.                                 else if(org.openspcoop2.core.registry.utils.XMLUtils.isRegistroServizi(element)) {
  248.                                     registryNameList.add(entryName);
  249.                                     registryList.add(bytes);
  250.                                 }
  251.                                 else if(org.openspcoop2.core.controllo_traffico.utils.XMLUtils.isConfigurazionePolicy(element)) {
  252.                                     controllaTrafficoConfigPolicyNameList.add(entryName);
  253.                                     controllaTrafficoConfigPolicyList.add(bytes);
  254.                                 }
  255.                                 else if(org.openspcoop2.core.controllo_traffico.utils.XMLUtils.isAttivazionePolicy(element)) {
  256.                                     controllaTrafficoActivePolicyNameList.add(entryName);
  257.                                     controllaTrafficoActivePolicyList.add(bytes);
  258.                                 }
  259.                                 else {
  260.                                     throw new UtilsException("unknown type");
  261.                                 }
  262.                                 
  263.                             }
  264.                         }catch(Exception e) {
  265.                             this.logError("PreLoading entry ["+zipEntry.getName()+"] error: "+e.getMessage(),e);
  266.                         }
  267.                     }finally {
  268.                         try {
  269.                             if(isZip!=null) {
  270.                                 isZip.close();
  271.                             }
  272.                         }catch(Exception e) {
  273.                             // close
  274.                         }
  275.                     }
  276.                 }
  277.             }
  278.         }finally {
  279.             try {
  280.                 java.nio.file.Files.delete(fTmp.toPath());
  281.             }catch(Exception e) {
  282.                 // ignore
  283.             }
  284.         }

  286.         if(!pluginNameList.isEmpty()) {
  287.             
  288.             org.openspcoop2.core.plugins.utils.serializer.JaxbDeserializer deserializerCT = new  org.openspcoop2.core.plugins.utils.serializer.JaxbDeserializer (); 
  289.             DriverConfigurazioneDB driverConfigurazione = (DriverConfigurazioneDB) ConfigurazionePdDReader.getDriverConfigurazionePdD();
  290.             Connection con = null;
  291.             try {
  292.                 con = driverConfigurazione.getConnection("preloading plugins");
  293.                 ServiceManagerProperties jdbcProperties = new ServiceManagerProperties();
  294.                 jdbcProperties.setDatabaseType(driverConfigurazione.getTipoDB());
  295.                 jdbcProperties.setShowSql(true);
  296.                 org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager serviceManager = 
  297.                         new org.openspcoop2.core.plugins.dao.jdbc.JDBCServiceManager(con, jdbcProperties, this.log);
  298.                 org.openspcoop2.core.plugins.dao.IPluginService service = serviceManager.getPluginService();
  299.                 
  300.                 org.openspcoop2.core.plugins.utils.CleanerOpenSPCoop2Extensions cleaner = new org.openspcoop2.core.plugins.utils.CleanerOpenSPCoop2Extensions();
  301.                 
  302.                 for (int i = 0; i < pluginNameList.size(); i++) {
  303.                     String name = pluginNameList.get(i);
  304.                     byte [] content = pluginList.get(i);
  305.                     
  306.                     try {
  307.                         this.logInfo(getMessageInCorso(ID_PLUGIN, name));
  308.                         org.openspcoop2.core.plugins.Plugin plugin = deserializerCT.readPlugin(content);
  309.                         IdPlugin id = new IdPlugin();
  310.                         id.setClassName(plugin.getClassName());
  311.                         id.setLabel(plugin.getLabel());
  312.                         id.setTipo(plugin.getTipo());
  313.                         id.setTipoPlugin(plugin.getTipoPlugin());
  314.                         if(!service.exists(id)) {
  315.                             cleaner.clean(plugin);
  316.                             service.create(plugin);
  317.                         }
  318.                         this.logInfo(getMessageEffettuataConSuccesso(ID_PLUGIN, name));
  319.         
  320.                     }catch(Exception e) {
  321.                         this.logError(getMessageError(ID_PLUGIN, name, e),e);
  322.                     }
  323.                 }
  324.             }finally {
  325.                 driverConfigurazione.releaseConnection(con);
  326.             }
  327.         }
  328.         
  329.         if(!registryNameList.isEmpty()) {
  330.             org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializerRegistry = new  org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer (); 
  331.             java.util.Map<String, IDriverRegistroServiziGet> mapRegistri = RegistroServiziReader.getDriverRegistroServizi();
  332.             DriverRegistroServiziDB driverRegistroServizi = (DriverRegistroServiziDB) mapRegistri.values().iterator().next();
  333.             
  334.             for (int i = 0; i < registryNameList.size(); i++) {
  335.                 String name = registryNameList.get(i);
  336.                 byte [] content = registryList.get(i);
  337.                 
  338.                 convert(contentList, content, name, deserializerRegistry, driverRegistroServizi);
  339.             }
  340.         }
  341.         
  342.         if(!configNameList.isEmpty()) {
  343.             org.openspcoop2.core.config.utils.serializer.JaxbDeserializer deserializerConfig = new  org.openspcoop2.core.config.utils.serializer.JaxbDeserializer (); 
  344.             DriverConfigurazioneDB driverConfigurazione = (DriverConfigurazioneDB) ConfigurazionePdDReader.getDriverConfigurazionePdD();
  345.             
  346.             for (int i = 0; i < configNameList.size(); i++) {
  347.                 String name = configNameList.get(i);
  348.                 byte [] content = configList.get(i);
  349.                 
  350.                 try {
  351.                     this.logInfo(getMessageInCorso(ID_CONFIG, name));
  352.                     Openspcoop2 op2 = deserializerConfig.readOpenspcoop2(content);
  353.                     
  354.                     Configurazione config = op2.getConfigurazione();
  355.                     if(config!=null &&
  356.                         config.getGenericPropertiesList()!=null && !config.getGenericPropertiesList().isEmpty()) {
  357.                         for (GenericProperties genericProperties : config.getGenericPropertiesList()) {
  358.                             boolean exists = existsGenericProperties(driverConfigurazione, genericProperties);
  359.                             if(!exists) {
  360.                                 driverConfigurazione.createGenericProperties(genericProperties);
  361.                             }
  362.                         }
  363.                     }
  364.                     
  365.                     if(op2.sizeSoggettoList()>0) {
  366.                         convert(driverConfigurazione, content, config, op2);
  367.                     }
  368.                     
  369.                     this.logInfo(getMessageEffettuataConSuccesso(ID_CONFIG, name));
  370.     
  371.                 }catch(Exception e) {
  372.                     this.logError(getMessageError(ID_CONFIG, name, e),e);
  373.                 }
  374.             }
  375.         }
  376.         
  377.         
  378.         
  379.         if(!controllaTrafficoConfigPolicyNameList.isEmpty()) {
  380.             org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer deserializerCT = new  org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer (); 
  381.             DriverConfigurazioneDB driverConfigurazione = (DriverConfigurazioneDB) ConfigurazionePdDReader.getDriverConfigurazionePdD();
  382.             Connection con = null;
  383.             try {
  384.                 con = driverConfigurazione.getConnection("preloading controllaTrafficoConfigPolicies");
  385.                 ServiceManagerProperties jdbcProperties = new ServiceManagerProperties();
  386.                 jdbcProperties.setDatabaseType(driverConfigurazione.getTipoDB());
  387.                 jdbcProperties.setShowSql(true);
  388.                 org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager serviceManager = 
  389.                         new org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager(con, jdbcProperties, this.log);
  390.                 org.openspcoop2.core.controllo_traffico.dao.IConfigurazionePolicyService service = serviceManager.getConfigurazionePolicyService();
  391.                 
  392.                 org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions cleaner = new org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions();
  393.                 
  394.                 for (int i = 0; i < controllaTrafficoConfigPolicyNameList.size(); i++) {
  395.                     String name = controllaTrafficoConfigPolicyNameList.get(i);
  396.                     byte [] content = controllaTrafficoConfigPolicyList.get(i);
  397.                     
  398.                     try {
  399.                         this.logInfo(getMessageInCorso(ID_CONTROLLO_TRAFFICO_CONFIG_POLICY, name));
  400.                         org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy policy = deserializerCT.readConfigurazionePolicy(content);
  401.                         IdPolicy id = new IdPolicy();
  402.                         id.setNome(policy.getIdPolicy());
  403.                         if(!service.exists(id)) {
  404.                             cleaner.clean(policy);
  405.                             service.create(policy);
  406.                         }
  407.                         this.logInfo(getMessageEffettuataConSuccesso(ID_CONTROLLO_TRAFFICO_CONFIG_POLICY, name));
  408.         
  409.                     }catch(Exception e) {
  410.                         this.logError(getMessageError(ID_CONTROLLO_TRAFFICO_CONFIG_POLICY, name, e),e);
  411.                     }
  412.                 }
  413.             }finally {
  414.                 driverConfigurazione.releaseConnection(con);
  415.             }
  416.         }
  417.         
  418.         if(!controllaTrafficoActivePolicyNameList.isEmpty()) {
  419.             org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer deserializerCT = new  org.openspcoop2.core.controllo_traffico.utils.serializer.JaxbDeserializer (); 
  420.             DriverConfigurazioneDB driverConfigurazione = (DriverConfigurazioneDB) ConfigurazionePdDReader.getDriverConfigurazionePdD();
  421.             Connection con = null;
  422.             try {
  423.                 con = driverConfigurazione.getConnection("preloading controllaTrafficoActivePolicies");
  424.                 ServiceManagerProperties jdbcProperties = new ServiceManagerProperties();
  425.                 jdbcProperties.setDatabaseType(driverConfigurazione.getTipoDB());
  426.                 jdbcProperties.setShowSql(true);
  427.                 org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager serviceManager = 
  428.                         new org.openspcoop2.core.controllo_traffico.dao.jdbc.JDBCServiceManager(con, jdbcProperties, this.log);
  429.                 org.openspcoop2.core.controllo_traffico.dao.IAttivazionePolicyService service = serviceManager.getAttivazionePolicyService();
  430.                 
  431.                 org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions cleaner = new org.openspcoop2.core.controllo_traffico.utils.CleanerOpenSPCoop2Extensions();
  432.                 
  433.                 for (int i = 0; i < controllaTrafficoActivePolicyNameList.size(); i++) {
  434.                     String name = controllaTrafficoActivePolicyNameList.get(i);
  435.                     byte [] content = controllaTrafficoActivePolicyList.get(i);
  436.                     
  437.                     try {
  438.                         this.logInfo(getMessageInCorso(ID_CONTROLLO_TRAFFICO_ACTIVE_POLICY, name));
  439.                         org.openspcoop2.core.controllo_traffico.AttivazionePolicy policy = deserializerCT.readAttivazionePolicy(content);
  440.                         IdActivePolicy id = new IdActivePolicy();
  441.                         id.setNome(policy.getIdActivePolicy());
  442.                         if(!service.exists(id)) {
  443.                             cleaner.clean(policy);
  444.                             service.create(policy);
  445.                         }
  446.                         this.logInfo(getMessageEffettuataConSuccesso(ID_CONTROLLO_TRAFFICO_ACTIVE_POLICY, name));
  447.         
  448.                     }catch(Exception e) {
  449.                         this.logError(getMessageError(ID_CONTROLLO_TRAFFICO_ACTIVE_POLICY, name, e),e);
  450.                     }
  451.                 }
  452.             }finally {
  453.                 driverConfigurazione.releaseConnection(con);
  454.             }
  455.         }

  457.     }
  458.     
  459.     private int converPosizione(String posizioneEntry) throws UtilsException {
  460.         try {
  461.             return Integer.valueOf(posizioneEntry);
  462.         }catch(Exception e) {
  463.             throw new UtilsException("Nome file 'wsdl' con posizione non intera '"+posizioneEntry+"': "+e.getMessage());
  464.         }
  465.     }
  466.     
  467.     private String convertVariable(String tmp) throws RegExpException, RegExpNotValidException {
  468.         String pattern = "\\$\\{([A-Za-z0-9_]+)\\}";
  469.         List<String> l = null;
  470.         try {
  471.             l = RegularExpressionEngine.getAllStringFindPattern(tmp, pattern);
  472.         }catch(RegExpNotFoundException notFound) {
  473.             // ignore
  474.         }
  475.         return convertVariable(l, tmp);
  476.     }
  477.     private String convertVariable(List<String> l, String tmp) {
  478.         if(l!=null && !l.isEmpty()) {
  479.             for (String varName : l) {
  480.                 String valueSystemProperty = convertVariabile(varName);
  481.                 if(valueSystemProperty!=null) {
  482.                     String expr = "${"+varName+"}";
  483.                     int i = 0;
  484.                     int max = 1000;
  485.                     while(tmp.contains(expr) && i<max) {
  486.                         tmp = tmp.replace(expr, valueSystemProperty);
  487.                         i++;
  488.                     }
  489.                 }
  490.             }
  491.         }
  492.         return tmp;
  493.     }
  494.     private String convertVariabile(String varName) {
  495.         String valueSystemProperty = System.getenv(varName); // sistema
  496.         if(valueSystemProperty==null) {
  497.             valueSystemProperty = System.getProperty(varName); // java
  498.         }
  499.         return valueSystemProperty;
  500.     }
  501.         
  502.     private static final String PRELOADING_PREFIX = "PreLoading ";
  503.     private String getMessageInCorso(String type, String name) {
  504.         return PRELOADING_PREFIX+type+" ["+name+"] ...";
  505.     }
  506.     private String getMessageEffettuataConSuccesso(String type, String name) {
  507.         return PRELOADING_PREFIX+type+" ["+name+"] effettuato con successo";
  508.     }
  509.     private String getMessageError(String type, String name, Exception e) {
  510.         return PRELOADING_PREFIX+type+" ["+name+"] failed: "+e.getMessage();
  511.     }
  512.     private static final String ID_PLUGIN= "Plugin";
  513.     private static final String ID_REGISTRY = "Registry";
  514.     private static final String ID_CONFIG = "Config";
  515.     private static final String ID_CONTROLLO_TRAFFICO_CONFIG_POLICY = "ControlloTraffico ConfigPolicy";
  516.     private static final String ID_CONTROLLO_TRAFFICO_ACTIVE_POLICY = "ControlloTraffico ActivePolicy";
  517.     
  518.     private UtilsException getUtilsExceptionDocumentoNonAssociabileApi(Document d, RegistroServizi registry) {
  519.         return new UtilsException("Documento '"+d.name+"' non associabile all'Api; la posizione indicata '"+d.index+"' è maggiore delle api disponibili '"+registry.sizeAccordoServizioParteComuneList()+"'");
  520.     }
  521.     
  522.     private void convert(HashMap<String, Document> contentList, byte[] content, String name, org.openspcoop2.core.registry.utils.serializer.JaxbDeserializer deserializerRegistry,
  523.             DriverRegistroServiziDB driverRegistroServizi) {
  524.         try {
  525.             this.logInfo(getMessageInCorso(ID_REGISTRY, name));
  526.             RegistroServizi registry = deserializerRegistry.readRegistroServizi(content); // verifico file
  527.             
  528.             setContent(contentList, name, registry);
  529.             
  530.             convert(registry, driverRegistroServizi);
  531.             
  532.             this.logInfo(getMessageEffettuataConSuccesso(ID_REGISTRY, name));

  534.         }catch(Exception e) {
  535.             this.logError(getMessageError(ID_REGISTRY, name, e),e);
  536.         }
  537.     }
  538.     private void setContent(HashMap<String, Document> contentList, String name, RegistroServizi registry) throws UtilsException {
  539.         if(contentList!=null && contentList.containsKey(name)) {
  540.             Document d = contentList.get(name);
  541.             if(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_CONCETTUALE_WSDL.equals(d.name)) {
  542.                 if(registry.sizeAccordoServizioParteComuneList()<=d.index) {
  543.                     throw getUtilsExceptionDocumentoNonAssociabileApi(d,  registry);
  544.                 }
  545.                 registry.getAccordoServizioParteComune(d.index).setByteWsdlConcettuale(d.content);
  546.             }
  547.             else if(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_EROGATORE_WSDL.equals(d.name)) {
  548.                 if(registry.sizeAccordoServizioParteComuneList()<=d.index) {
  549.                     throw getUtilsExceptionDocumentoNonAssociabileApi(d,  registry);
  550.                 }
  551.                 registry.getAccordoServizioParteComune(d.index).setByteWsdlLogicoErogatore(d.content);
  552.             }
  553.             else if(CostantiRegistroServizi.SPECIFICA_INTERFACCIA_LOGICA_FRUITORE_WSDL.equals(d.name)) {
  554.                 if(registry.sizeAccordoServizioParteComuneList()<=d.index) {
  555.                     throw getUtilsExceptionDocumentoNonAssociabileApi(d,  registry);
  556.                 }
  557.                 registry.getAccordoServizioParteComune(d.index).setByteWsdlLogicoFruitore(d.content);
  558.             }
  559.         }
  560.     }
  561.     private void convert(RegistroServizi registry, DriverRegistroServiziDB driverRegistroServizi) throws DriverRegistroServiziException {
  562.         try {
  563.             String superUser = null;
  564.             
  565.             org.openspcoop2.core.registry.driver.utils.XMLDataConverter xmlDataConverter = 
  566.                     new org.openspcoop2.core.registry.driver.utils.XMLDataConverter(registry,driverRegistroServizi,CostantiConfigurazione.REGISTRO_DB.getValue(),
  567.                             superUser,this.protocolloDefault,
  568.                             this.log,this.log);
  569.             boolean reset = false;
  570.             boolean mantieniFruitoriEsistenti = true;
  571.             boolean aggiornamentoSoggetti = false;
  572.             boolean updateEnabled = false; // per non modificare eventuali configurazioni gia' caricate, che possono essere state modificate
  573.             xmlDataConverter.convertXML(reset, mantieniFruitoriEsistenti,aggiornamentoSoggetti,StatiAccordo.operativo, updateEnabled);
  574.         }
  575.         finally {
  576.             // nop
  577.         }
  578.     }
  579.     
  580.     private boolean existsGenericProperties(DriverConfigurazioneDB driverConfigurazione, GenericProperties genericProperties) throws DriverConfigurazioneException {
  581.         try {
  582.             return driverConfigurazione.getGenericProperties(genericProperties.getTipologia(), genericProperties.getNome()) != null;
  583.         }catch(DriverConfigurazioneNotFound notFound) {
  584.             // ignore
  585.         }
  586.         return false;
  587.     }
  588.     
  589.     private void convert(DriverConfigurazioneDB driverConfigurazione, byte[] content, Configurazione config, Openspcoop2 op2) throws UtilsException, DriverConfigurazioneException {
  590.         byte [] contentXml = content;

  592.         if(config==null) {
  593.             op2.setConfigurazione(new Configurazione());
  594.             // ne carico una dummy, tanto non la uso
  595.             op2.getConfigurazione().setAccessoRegistro(new AccessoRegistro());
  596.             AccessoRegistroRegistro registro = new AccessoRegistroRegistro();
  597.             registro.setTipo(RegistroTipo.DB);
  598.             registro.setNome("dummy");
  599.             registro.setLocation("dummy");
  600.             op2.getConfigurazione().getAccessoRegistro().addRegistro(registro);
  601.             op2.getConfigurazione().setInoltroBusteNonRiscontrate(new InoltroBusteNonRiscontrate());
  602.             op2.getConfigurazione().getInoltroBusteNonRiscontrate().setCadenza("1");
  603.             op2.getConfigurazione().setMessaggiDiagnostici(new MessaggiDiagnostici());
  604.             op2.getConfigurazione().getMessaggiDiagnostici().setSeverita(Severita.INFO_INTEGRATION);
  605.             op2.getConfigurazione().getMessaggiDiagnostici().setSeveritaLog4j(Severita.INFO_INTEGRATION);
  606.             
  607.             CleanerOpenSPCoop2Extensions cleaner = new CleanerOpenSPCoop2Extensions();
  608.             cleaner.clean(op2.getConfigurazione());
  609.             for (Soggetto soggettoConfig : op2.getSoggettoList()) {
  610.                 cleaner.clean(soggettoConfig);
  611.                 
  612.                 for (PortaDelegata pdConfig : soggettoConfig.getPortaDelegataList()) {
  613.                     cleaner.clean(pdConfig);
  614.                 }
  615.                 for (PortaApplicativa paConfig : soggettoConfig.getPortaApplicativaList()) {
  616.                     cleaner.clean(paConfig);
  617.                 }
  618.                 for (ServizioApplicativo saConfig : soggettoConfig.getServizioApplicativoList()) {
  619.                     cleaner.clean(saConfig);
  620.                 }
  621.             }
  622.             
  623.             ByteArrayOutputStream bout = new ByteArrayOutputStream();
  624.             op2.writeTo(bout, WriteToSerializerType.XML_JAXB);
  625.             contentXml = bout.toByteArray();
  626.             
  627.         }
  628.         
  629.         boolean udpateConfigurazioneDisabled = false;
  630.         boolean tabellaSoggettiCondivisaPddRegserv = true;
  631.         String superUser = null;
  632.         org.openspcoop2.core.config.driver.utils.XMLDataConverter xmlDataConverter = 
  633.                 new org.openspcoop2.core.config.driver.utils.XMLDataConverter(contentXml,driverConfigurazione,CostantiConfigurazione.CONFIGURAZIONE_DB,
  634.                         udpateConfigurazioneDisabled,tabellaSoggettiCondivisaPddRegserv,superUser,this.protocolloDefault,
  635.                         this.log,this.log);
  636.         boolean reset = false;
  637.         boolean aggiornamentoSoggetti = false;
  638.         boolean createMappingErogazioneFruizione = true; // serve per creare il mapping ad es. sulle fruizioni ed erogazioni
  639.         boolean updateEnabled = false; // per non modificare eventuali configurazioni gia' caricate, che possono essere state modificate
  640.         xmlDataConverter.convertXML(reset, aggiornamentoSoggetti, createMappingErogazioneFruizione, updateEnabled);
  641.     }
  642. }

  644. class Document{
  645.     
  646.     byte[] content;
  647.     int index;
  648.     String name;
  649.     
  650. }
Created with JaCoCo 0.8.8.202204050719