SubscriptionConfiguration.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.PortaDelegata;
  31. import org.openspcoop2.core.config.PortaDelegataAzione;
  32. import org.openspcoop2.core.config.constants.PortaDelegataAzioneIdentificazione;
  33. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  34. import org.openspcoop2.core.controllo_traffico.utils.ControlloTrafficoDriverUtils;
  35. import org.openspcoop2.core.id.IDPortaDelegata;
  36. import org.openspcoop2.core.id.IDServizio;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  39. import org.openspcoop2.core.mapping.SubscriptionUtils;
  40. import org.openspcoop2.protocol.manifest.IntegrationConfiguration;
  41. import org.openspcoop2.protocol.manifest.IntegrationConfigurationResourceIdentificationMode;
  42. import org.openspcoop2.protocol.manifest.constants.ResourceIdentificationType;
  43. import org.openspcoop2.protocol.sdk.ProtocolException;
  44. import org.openspcoop2.protocol.sdk.config.ProtocolSubscription;
  45. import org.openspcoop2.protocol.sdk.constants.ConsoleInterfaceType;
  46. import org.openspcoop2.protocol.sdk.registry.IConfigIntegrationReader;

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

  57. public class SubscriptionConfiguration extends AbstractIntegrationConfiguration {

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

  64.     protected SubscriptionConfiguration(IntegrationConfiguration integrationConfiguration) {
  65.         super(integrationConfiguration);
  66.     }

  68.     public static boolean isDescriptionDefault(String descrizione) {
  69.         return descrizione!=null &&
  70.                 (descrizione.startsWith(SubscriptionConfiguration.SUBSCRIPTION_PREFIX) ||
  71.                 descrizione.startsWith(SubscriptionConfiguration.SUBSCRIPTION_PREFIX_2)||
  72.                 descrizione.startsWith(SubscriptionConfiguration.INTERNAL_SUBSCRIPTION_PREFIX));
  73.     }
  74.     
  75.     private static final String SUBSCRIPTION_PREFIX = "Subscription from ";
  76.     private static final String SUBSCRIPTION_PREFIX_2 = "Subscription for service ";
  77.     public ProtocolSubscription createDefaultSubscription(IDSoggetto idFruitore, IDServizio idServizio) throws ProtocolException {
  78.         
  79.         ProtocolSubscription subscription = new ProtocolSubscription();
  80.         
  81.         PortaDelegata portaDelegata = new PortaDelegata();
  82.         portaDelegata.setNome(this.getNome(idServizio, idFruitore, null, null, 
  83.                 this.integrationConfiguration.getName().getParamList()));
  84.         portaDelegata.setDescrizione(SUBSCRIPTION_PREFIX+idFruitore.toString()+" for service "+idServizio.toString());
  85.         if(portaDelegata.getDescrizione().length()>255) {
  86.             portaDelegata.setDescrizione(SUBSCRIPTION_PREFIX_2+idServizio.toString());
  87.         }
  88.         if(portaDelegata.getDescrizione().length()>255) {
  89.             portaDelegata.setDescrizione(null);
  90.         }
  91.         
  92.         IDPortaDelegata idPortaDelegata = SubscriptionUtils.setCommonParameter(portaDelegata, idFruitore, idServizio, true, false);

  94.         PortaDelegataAzione pdAzione = new PortaDelegataAzione();
  95.         ResourceIdentificationType defaultIdentification = this.integrationConfiguration.getResourceIdentification().getIdentificationModes().getDefault();
  96.         if(defaultIdentification==null) {
  97.             defaultIdentification = this.integrationConfiguration.getResourceIdentification().getIdentificationModes().getMode(0).getName();
  98.         }
  99.         boolean setPattern = false;
  100.         switch (defaultIdentification) {
  101.         case CONTENT:
  102.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.CONTENT_BASED);      
  103.             setPattern = true;
  104.             break;
  105.         case HEADER:
  106.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.HEADER_BASED);       
  107.             setPattern = true;
  108.             break;
  109.         case URL:
  110.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.URL_BASED);      
  111.             setPattern = true;
  112.             break;
  113.         case INPUT:
  114.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.INPUT_BASED);        
  115.             break;
  116.         case INTERFACE:
  117.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.INTERFACE_BASED);        
  118.             break;
  119.         case SOAP_ACTION:
  120.             pdAzione.setIdentificazione(PortaDelegataAzioneIdentificazione.SOAP_ACTION_BASED);      
  121.             break;
  122.         case PROTOCOL:
  123.             throw new ProtocolException("IdentificationMode '"+defaultIdentification+"' unsupported");
  124.         }
  125.         if(setPattern) {
  126.             pdAzione.setPattern(this.getNome(idServizio, idFruitore, portaDelegata.getNome(), null, 
  127.                     this.integrationConfiguration.getResourceIdentification().getIdentificationParameter().getParamList()));
  128.         }       
  129.         if(this.integrationConfiguration.getResourceIdentification().getIdentificationModes().isForceInterfaceMode()) {
  130.             pdAzione.setForceInterfaceBased(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO);
  131.         }
  132.         else {
  133.             pdAzione.setForceInterfaceBased(org.openspcoop2.core.config.constants.StatoFunzionalita.DISABILITATO);
  134.         }
  135.         portaDelegata.setAzione(pdAzione);

  137.         portaDelegata.setRicercaPortaAzioneDelegata(org.openspcoop2.core.config.constants.StatoFunzionalita.ABILITATO);
  138.         
  139.         subscription.setPortaDelegata(portaDelegata);       

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

  316.         portaDelegata.setNome(nomeNuovaPortaDelegata);
  317.         portaDelegata.setDescrizione(descrizioneNuovaPortaDelegata);
  318.         
  319.         IDPortaDelegata idPortaDelegata = SubscriptionUtils.setCommonParameter(portaDelegata, idFruitore, idServizio, setDatiServizio, portaClonata);
  320.         
  321.         SubscriptionUtils.setAzioneDelegate(portaDelegata, nomePortaDelegante, azione);
  322.                         
  323.         subscription.setPortaDelegata(portaDelegata);       

  325.         MappingFruizionePortaDelegata mappingFruizione = SubscriptionUtils.createMapping(idFruitore, idServizio, idPortaDelegata, ruleName, description);
  326.         
  327.         subscription.setMapping(mappingFruizione);
  328.         
  329.         return subscription;
  330.         
  331.     }
  332. }




Created with JaCoCo 0.8.8.202204050719