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



  23. package org.openspcoop2.protocol.basic.config;

  25. import java.util.ArrayList;
  26. import java.util.List;

  28. import org.openspcoop2.core.allarmi.Allarme;
  29. import org.openspcoop2.core.allarmi.utils.AllarmiDriverUtils;
  30. import org.openspcoop2.core.config.PortaApplicativa;
  31. import org.openspcoop2.core.config.PortaApplicativaAzione;
  32. import org.openspcoop2.core.config.constants.PortaApplicativaAzioneIdentificazione;
  33. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  34. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  35. import org.openspcoop2.core.id.IDPortaApplicativa;
  36. import org.openspcoop2.core.id.IDServizio;
  37. import org.openspcoop2.core.mapping.ImplementationUtils;
  38. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  39. import org.openspcoop2.protocol.manifest.IntegrationConfiguration;
  40. import org.openspcoop2.protocol.manifest.IntegrationConfigurationResourceIdentificationMode;
  41. import org.openspcoop2.protocol.manifest.constants.ResourceIdentificationType;
  42. import org.openspcoop2.protocol.sdk.ProtocolException;
  43. import org.openspcoop2.protocol.sdk.config.ProtocolImplementation;
  44. import org.openspcoop2.protocol.sdk.constants.ConsoleInterfaceType;
  45. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;

  47. /**
  48.  * ImplementationConfiguration
  49.  *
  50.  *
  51.  * @author Poli Andrea (apoli@link.it)
  52.  * @author $Author$
  53.  * @version $Rev$, $Date$
  54.  */

  56. public class ImplementationConfiguration extends AbstractIntegrationConfiguration {

  58.     /**
  59.      * 
  60.      */
  61.     private static final long serialVersionUID = 1L;

  63.     protected ImplementationConfiguration(IntegrationConfiguration integrationConfiguration) {
  64.         super(integrationConfiguration);
  65.     }
  66.     
  67.     public static boolean isDescriptionDefault(String descrizione) {
  68.         return descrizione!=null &&
  69.                 (descrizione.startsWith(ImplementationConfiguration.INTERNAL_IMPLEMENTATION_PREFIX) ||
  70.                 descrizione.startsWith(ImplementationConfiguration.SERVICE_IMPLEMENTATION_PREFIX));
  71.     }

  73.     private static final String SERVICE_IMPLEMENTATION_PREFIX = "Service implementation ";
  74.     public ProtocolImplementation createDefaultImplementation(IDServizio idServizio) throws ProtocolException {
  75.         
  76.         ProtocolImplementation implementation = new ProtocolImplementation();
  77.         
  78.         PortaApplicativa portaApplicativa = new PortaApplicativa();
  79.         portaApplicativa.setNome(this.getNome(idServizio, null, null, null, 
  80.                 this.integrationConfiguration.getName().getParamList()));
  81.         portaApplicativa.setDescrizione(SERVICE_IMPLEMENTATION_PREFIX+idServizio.toString());
  82.         if(portaApplicativa.getDescrizione().length()>255) {
  83.             portaApplicativa.setDescrizione(SERVICE_IMPLEMENTATION_PREFIX+idServizio.toString());
  84.         }
  85.         if(portaApplicativa.getDescrizione().length()>255) {
  86.             portaApplicativa.setDescrizione(null);
  87.         }
  88.         
  89.         IDPortaApplicativa idPortaApplicativa = ImplementationUtils.setCommonParameter(portaApplicativa, idServizio, true, false);
  90.         
  91.         PortaApplicativaAzione pdAzione = new PortaApplicativaAzione();
  92.         ResourceIdentificationType defaultIdentification = this.integrationConfiguration.getResourceIdentification().getIdentificationModes().getDefault();
  93.         if(defaultIdentification==null) {
  94.             defaultIdentification = this.integrationConfiguration.getResourceIdentification().getIdentificationModes().getMode(0).getName();
  95.         }
  96.         boolean setPattern = false;
  97.         switch (defaultIdentification) {
  98.         case CONTENT:
  99.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.CONTENT_BASED);       
  100.             setPattern = true;
  101.             break;
  102.         case HEADER:
  103.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.HEADER_BASED);        
  104.             setPattern = true;
  105.             break;
  106.         case URL:
  107.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.URL_BASED);       
  108.             setPattern = true;
  109.             break;
  110.         case INPUT:
  111.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.INPUT_BASED);     
  112.             break;
  113.         case INTERFACE:
  114.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.INTERFACE_BASED);     
  115.             break;
  116.         case SOAP_ACTION:
  117.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.SOAP_ACTION_BASED);       
  118.             break;
  119.         case PROTOCOL:
  120.             pdAzione.setIdentificazione(PortaApplicativaAzioneIdentificazione.PROTOCOL_BASED);
  121.             break;
  122.         }
  123.         if(setPattern) {
  124.             pdAzione.setPattern(this.getNome(idServizio, null, portaApplicativa.getNome(), null, 
  125.                     this.integrationConfiguration.getResourceIdentification().getIdentificationParameter().getParamList()));
  126.         }       
  127.         if(this.integrationConfiguration.getResourceIdentification().getIdentificationModes().isForceInterfaceMode()) {
  128.             pdAzione.setForceInterfaceBased(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO);
  129.         }
  130.         else {
  131.             pdAzione.setForceInterfaceBased(org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO);
  132.         }
  133.         portaApplicativa.setAzione(pdAzione);

  135.         portaApplicativa.setRicercaPortaAzioneDelegata(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO);
  136.         
  137.         implementation.setPortaApplicativa(portaApplicativa);       

  139.         MappingErogazionePortaApplicativa mappingErogazione = ImplementationUtils.createMappingDefault(idServizio, idPortaApplicativa); 
  140.                 
  141.         implementation.setMapping(mappingErogazione);
  142.         
  143.         return implementation;
  144.         
  145.         
  146.     }
  147.     
  148.     public List<PortaApplicativaAzioneIdentificazione> supportedIdentificationModes(ConsoleInterfaceType consoleType) {
  149.         List<PortaApplicativaAzioneIdentificazione> list = new ArrayList<>();
  150.         for (IntegrationConfigurationResourceIdentificationMode mode : 
  151.             this.integrationConfiguration.getResourceIdentification().getIdentificationModes().getModeList()) {
  152.             
  153.             if(mode.isOnlyAdvancedMode() &&
  154.                 ConsoleInterfaceType.STANDARD.equals(consoleType)) {
  155.                 continue;
  156.             }
  157.             
  158.             ResourceIdentificationType type = mode.getName();
  159.             switch (type) {
  160.             case CONTENT:
  161.                 list.add(PortaApplicativaAzioneIdentificazione.CONTENT_BASED);      
  162.                 break;
  163.             case HEADER:
  164.                 list.add(PortaApplicativaAzioneIdentificazione.HEADER_BASED);       
  165.                 break;
  166.             case URL:
  167.                 list.add(PortaApplicativaAzioneIdentificazione.URL_BASED);      
  168.                 break;
  169.             case INPUT:
  170.                 list.add(PortaApplicativaAzioneIdentificazione.INPUT_BASED);        
  171.                 break;
  172.             case INTERFACE:
  173.                 list.add(PortaApplicativaAzioneIdentificazione.INTERFACE_BASED);        
  174.                 break;
  175.             case SOAP_ACTION:
  176.                 list.add(PortaApplicativaAzioneIdentificazione.SOAP_ACTION_BASED);      
  177.                 break;
  178.             case PROTOCOL:
  179.                 list.add(PortaApplicativaAzioneIdentificazione.PROTOCOL_BASED); 
  180. /**             throw new ProtocolException("IdentificationMode '"+type+"' unsupported");*/
  181.             }
  182.         }
  183.         return list;
  184.     }
  185.     
  186.     public ProtocolImplementation createImplementation(IConfigIntegrationReader configIntegrationReader, IDServizio idServizio,
  187.             PortaApplicativa portaApplicativaDefault, 
  188.             String ruleName, String description, String ... azione ) throws ProtocolException {
  189.         return createImplementation(configIntegrationReader, idServizio, 
  190.                 portaApplicativaDefault, null, 
  191.                 ruleName, description, azione);
  192.     }
  193.     private static final String INTERNAL_IMPLEMENTATION_PREFIX = "Internal Implementation '";
  194.     public ProtocolImplementation createImplementation(IConfigIntegrationReader configIntegrationReader, IDServizio idServizio,
  195.             PortaApplicativa portaApplicativaDefault, PortaApplicativa portaApplicativaDaClonare,
  196.             String ruleName, String description, String ... azione ) throws ProtocolException {
  197.         
  198.         if(azione==null || azione.length<=0) {
  199.             throw new ProtocolException("Actions undefined");
  200.         }
  201.         
  202.         String nomePortaDelegante = portaApplicativaDefault.getNome();
  203.         String nomeNuovaPortaApplicativa = this.getNome(idServizio, null, nomePortaDelegante, ruleName, 
  204.                 this.integrationConfiguration.getResourceIdentification().getSpecificResource().getName().getParamList());
  205.         String descrizioneNuovaPortaApplicativa = INTERNAL_IMPLEMENTATION_PREFIX+ruleName+"' for "+nomePortaDelegante;  
  206.         if(descrizioneNuovaPortaApplicativa.length()>255) {
  207.             descrizioneNuovaPortaApplicativa = INTERNAL_IMPLEMENTATION_PREFIX+ruleName+"'";
  208.         }
  209.         if(descrizioneNuovaPortaApplicativa.length()>255) {
  210.             descrizioneNuovaPortaApplicativa = null;
  211.         }
  212.         
  213.         ProtocolImplementation implementation = new ProtocolImplementation();
  214.         
  215.         PortaApplicativa portaApplicativa = null;
  216.         
  217.         // creo una nuova porta applicativa clonando quella selezionata 
  218.         boolean setDatiServizio = false;
  219.         boolean portaClonata = false;
  220.         if(portaApplicativaDaClonare!=null) {
  221.             
  222.             portaApplicativa = (PortaApplicativa) portaApplicativaDaClonare.clone();
  223.             portaApplicativa.setId(null);// annullo il table id
  224.             portaApplicativa.setGestioneCors(null); // annulla la gestione Cors poiche' gestito solo nella porta di default
  225.             portaApplicativa.setCanale(null); // annullo il canale poiche' gestito solo nella porta di default
  226.             
  227.             IDPortaApplicativa idPA = new IDPortaApplicativa();
  228.             idPA.setNome(portaApplicativaDaClonare.getNome());
  229.             
  230.             // riporto Rate Limiting
  231.             List<AttivazionePolicy> listAP = null;
  232.             try {
  233.                 listAP = configIntegrationReader.getRateLimitingPolicy(idPA);
  234.             }catch(Exception e) {
  235.                 // ignore
  236.             }
  237.             List<String> idPolicyCreate = new ArrayList<>();
  238.             if(listAP!=null && !listAP.isEmpty()) {
  239.                 for (AttivazionePolicy attivazionePolicy : listAP) {
  240.                     
  241.                     AttivazionePolicy apCloned = (AttivazionePolicy) attivazionePolicy.clone();
  242.                     if(apCloned.getIdPolicy()!=null && apCloned.getFiltro()!=null && portaApplicativaDaClonare.getNome().equals(apCloned.getFiltro().getNomePorta())){
  243.                         try {
  244.                             apCloned.getFiltro().setNomePorta(nomeNuovaPortaApplicativa);
  245.                             String serialId = configIntegrationReader.getNextPolicyInstanceSerialId(apCloned.getIdPolicy());
  246.                             String idActive = ControlloTrafficoDriverUtils.buildIdActivePolicy(apCloned.getIdPolicy(), serialId);
  247.                             int limit = 0;
  248.                             while(idPolicyCreate.contains(idActive) && limit<1000) { // provo 1000 volte
  249.                                 limit++;
  250.                                 serialId = ControlloTrafficoDriverUtils.incrementPolicyInstanceSerialId(serialId);
  251.                                 idActive = ControlloTrafficoDriverUtils.buildIdActivePolicy(apCloned.getIdPolicy(), serialId);
  252.                             }
  253.                             idPolicyCreate.add(idActive);
  254.                             apCloned.setIdActivePolicy(idActive);
  255.                             
  256.                             if(implementation.getRateLimitingPolicies()==null) {
  257.                                 implementation.setRateLimitingPolicies(new ArrayList<>());
  258.                             }
  259.                             implementation.getRateLimitingPolicies().add(apCloned);
  260.                             
  261.                         }catch(Exception e) {
  262.                             // ignore
  263.                         }
  264.                     }
  265.                 }
  266.             }
  267.             
  268.             // riporto Allarmi
  269.             List<Allarme> listAllarmi = null;
  270.             try {
  271.                 listAllarmi = configIntegrationReader.getAllarmi(idPA);
  272.             }catch(Exception e) {
  273.                 // ignore
  274.             }
  275.             List<String> idAllarmiCreate = new ArrayList<>();
  276.             if(listAllarmi!=null && !listAllarmi.isEmpty()) {
  277.                 for (Allarme allarme : listAllarmi) {
  278.                     
  279.                     Allarme allarmeCloned = (Allarme) allarme.clone();
  280.                     if(allarmeCloned.getTipo()!=null && allarmeCloned.getFiltro()!=null && portaApplicativaDaClonare.getNome().equals(allarmeCloned.getFiltro().getNomePorta())){
  281.                         try {
  282.                             allarmeCloned.getFiltro().setNomePorta(nomeNuovaPortaApplicativa);
  283.                             String serialId = configIntegrationReader.getNextAlarmInstanceSerialId(allarmeCloned.getTipo());
  284.                             String uniqueName = AllarmiDriverUtils.buildIdAlarm(allarmeCloned.getTipo(), serialId);
  285.                             int limit = 0;
  286.                             while(idAllarmiCreate.contains(uniqueName) && limit<1000) { // provo 1000 volte
  287.                                 limit++;
  288.                                 serialId = AllarmiDriverUtils.incrementAlarmInstanceSerialId(serialId);
  289.                                 uniqueName = AllarmiDriverUtils.buildIdAlarm(allarmeCloned.getTipo(), serialId);
  290.                             }
  291.                             idAllarmiCreate.add(uniqueName);
  292.                             allarmeCloned.setNome(uniqueName);
  293.                             
  294.                             if(implementation.getAllarmi()==null) {
  295.                                 implementation.setAllarmi(new ArrayList<>());
  296.                             }
  297.                             implementation.getAllarmi().add(allarmeCloned);
  298.                             
  299.                         }catch(Exception e) {
  300.                             // ignore
  301.                         }
  302.                     }
  303.                 }
  304.             }
  305.             
  306.             portaClonata = true;
  307.         
  308.         } else {
  309.             
  310.             portaApplicativa = new PortaApplicativa();
  311.             setDatiServizio = true;     
  312.             
  313.         }

  315.         portaApplicativa.setNome(nomeNuovaPortaApplicativa);
  316.         portaApplicativa.setDescrizione(descrizioneNuovaPortaApplicativa);
  317.         
  318.         IDPortaApplicativa idPortaApplicativa = ImplementationUtils.setCommonParameter(portaApplicativa, idServizio, setDatiServizio, portaClonata);
  319.         
  320.         ImplementationUtils.setAzioneDelegate(portaApplicativa, nomePortaDelegante, azione);
  321.                 
  322.         implementation.setPortaApplicativa(portaApplicativa);       

  324.         MappingErogazionePortaApplicativa mappingErogazione = ImplementationUtils.createMapping(idServizio, idPortaApplicativa, ruleName, description);
  325.         
  326.         implementation.setMapping(mappingErogazione);
  327.         
  328.         return implementation;
  329.         
  330.     }
  331. }




Created with JaCoCo 0.8.8.202204050719