ServiceBindingConfiguration.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.message.config;

  23. import java.io.Serializable;
  24. import java.util.ArrayList;
  25. import java.util.HashMap;
  26. import java.util.List;
  27. import java.util.Map;

  29. import javax.mail.internet.ContentType;

  31. import org.openspcoop2.message.constants.Costanti;
  32. import org.openspcoop2.message.constants.MessageRole;
  33. import org.openspcoop2.message.constants.MessageType;
  34. import org.openspcoop2.message.constants.ServiceBinding;
  35. import org.openspcoop2.message.exception.MessageException;
  36. import org.openspcoop2.utils.transport.TransportRequestContext;
  37. import org.openspcoop2.utils.transport.http.ContentTypeUtilities;

  39. /**
  40.  * MessageConfiguration
  41.  *
  42.  * @author Poli Andrea (apoli@link.it)
  43.  * @author $Author$
  44.  * @version $Rev$, $Date$
  45.  */
  46. public class ServiceBindingConfiguration implements Serializable {

  48.     public static String normalizeContext(String context){
  49.         if(context==null || "".equals(context)){
  50.             return Costanti.CONTEXT_EMPTY;
  51.         }
  52.         return context;
  53.     }
  54.     
  55.     /**
  56.      * 
  57.      */
  58.     private static final long serialVersionUID = 1L;
  59.     
  60.     private ServiceBinding defaultBinding;
  61.     private ConfigurationServiceBindingSoap soap;   
  62.     private ConfigurationServiceBindingRest rest;
  63.     private ContextUrlCollection contextUrlCollection;
  64.     
  65.     private Map<String, ServiceBinding> restrictedServiceBindingContextUrl = new HashMap<String, ServiceBinding>();
  66.     private Map<String, ServiceBinding> restrictedServiceBindingServiceType = new HashMap<String, ServiceBinding>();
  67.     
  68.     public ServiceBindingConfiguration(ServiceBinding defaultBinding, 
  69.             ConfigurationServiceBindingSoap soap, ConfigurationServiceBindingRest rest,
  70.             ContextUrlCollection contextUrlCollection) throws MessageException{
  71.         if(defaultBinding==null){
  72.             throw new MessageException("Default ServiceBinding not defined");
  73.         }
  74.         if(soap==null){
  75.             throw new MessageException("SOAP-ServiceBinding not defined");
  76.         }
  77.         if(rest==null){
  78.             throw new MessageException("REST-ServiceBinding not defined");
  79.         }
  80.         this.defaultBinding = defaultBinding;
  81.         this.soap = soap;
  82.         this.rest = rest;
  83.         if(contextUrlCollection==null){
  84.             this.contextUrlCollection = new ContextUrlCollection(this.soap.getBinding(),this.rest.getBinding());
  85.         }
  86.         else{
  87.             this.contextUrlCollection = contextUrlCollection;
  88.         }
  89.     }
  90.     
  91.     
  92.     // ----- SERVICE BINDING ------
  93.     
  94.     public ServiceBinding getDefaultBinding() {
  95.         return this.defaultBinding;
  96.     }
  97.     
  98.     public boolean isServiceBindingSupported(ServiceBinding serviceBinding){
  99.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  100.             return this.soap.isEnabled();
  101.         }
  102.         else {
  103.             return this.rest.isEnabled();
  104.         }
  105.     }
  106.     
  107.     public List<MessageType> getMessageTypeSupported(ServiceBinding serviceBinding){
  108.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  109.             return this.soap.getMessageTypeSupported();
  110.         }
  111.         else {
  112.             return this.rest.getMessageTypeSupported();
  113.         }
  114.     }
  115.     
  116.     public boolean isServiceBindingContextEnabled(ServiceBinding serviceBinding, String contextParam){
  117.         String context = normalizeContext(contextParam);
  118.         if(this.restrictedServiceBindingContextUrl.containsKey(context)){
  119.             if(ServiceBinding.SOAP.equals(this.restrictedServiceBindingContextUrl.get(context))){
  120.                 return ServiceBinding.SOAP.equals(serviceBinding);
  121.             }
  122.             else {
  123.                 return ServiceBinding.REST.equals(serviceBinding);
  124.             }
  125.         }
  126.         return true;
  127.     }
  128.         

  130.     public boolean isServiceBindingServiceTypeEnabled(ServiceBinding serviceBinding, String serviceType){
  131.         if(this.restrictedServiceBindingServiceType.containsKey(serviceType)){
  132.             if(ServiceBinding.SOAP.equals(this.restrictedServiceBindingServiceType.get(serviceType))){
  133.                 return ServiceBinding.SOAP.equals(serviceBinding);
  134.             }
  135.             else {
  136.                 return ServiceBinding.REST.equals(serviceBinding);
  137.             }
  138.         }
  139.         return true;
  140.     }
  141.     
  142.     public void addServiceBindingContextRestriction(ServiceBinding serviceBinding, String contextParam){
  143.         String context = normalizeContext(contextParam);
  144.         if(this.restrictedServiceBindingContextUrl.containsKey(context)){
  145.             this.restrictedServiceBindingContextUrl.remove(context);
  146.         }
  147.         this.restrictedServiceBindingContextUrl.put(context, serviceBinding);
  148.     }
  149.     
  150.     public void addServiceBindingEmptyContextRestriction(ServiceBinding serviceBinding){
  151.         this.addServiceBindingContextRestriction(serviceBinding, null);
  152.     }
  153.     
  154.     public void addServiceBindingServiceTypeRestriction(ServiceBinding serviceBinding, String serviceType){
  155.         if(this.restrictedServiceBindingServiceType.containsKey(serviceType)){
  156.             this.restrictedServiceBindingServiceType.remove(serviceType);
  157.         }
  158.         this.restrictedServiceBindingServiceType.put(serviceType, serviceBinding);
  159.     }
  160.     
  161.     
  162.     
  163.     // ----- INTEGRATION ERROR ------
  164.     
  165.     public IntegrationErrorCollection getInternalIntegrationErrorConfiguration(ServiceBinding serviceBinding) {
  166.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  167.             return this.soap.getInternalIntegrationErrorConfiguration();
  168.         }
  169.         else {
  170.             return this.rest.getInternalIntegrationErrorConfiguration();
  171.         }
  172.     }
  173.     public IntegrationErrorCollection getExternalIntegrationErrorConfiguration(ServiceBinding serviceBinding) {
  174.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  175.             return this.soap.getExternalIntegrationErrorConfiguration();
  176.         }
  177.         else {
  178.             return this.rest.getExternalIntegrationErrorConfiguration();
  179.         }
  180.     }
  181.     

  183.     
  184.     // ----- MESSAGE TYPES ------
  185.     
  186.     public boolean existsContextUrlMapping(){
  187.         return this.contextUrlCollection!=null && this.contextUrlCollection.sizeContextUrl()>0;
  188.     }
  189.     
  190.     public List<String> getContentTypesSupported(ServiceBinding serviceBinding, MessageRole messageType, 
  191.             TransportRequestContext transportContext) throws MessageException{
  192.         return getContentTypesSupported(serviceBinding, messageType, 
  193.                 transportContext.getProtocolWebContext(), transportContext.getFunction(), transportContext.getFunctionParameters());
  194.     }
  195.     public List<String> getContentTypesSupported(ServiceBinding serviceBinding, MessageRole messageType, 
  196.             String protocol, String function, String functionParameters) throws MessageException{
  197.         
  198.         if(serviceBinding==null){
  199.             throw new MessageException("ServiceBinding not defined");
  200.         }
  201.         if(messageType==null){
  202.             throw new MessageException("MessageType not defined");
  203.         }
  204.         
  205.         AbstractMediaTypeCollection configurationFlow;

  207.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  208.             if(this.soap.isEnabled()==false){
  209.                 throw new MessageException("Typology ["+serviceBinding+"] not supported");
  210.             }
  211.             if(MessageRole.REQUEST.equals(messageType)){
  212.                 configurationFlow = this.soap.getRequest();
  213.             }
  214.             else{
  215.                 configurationFlow = this.soap.getResponse();
  216.             }
  217.         }
  218.         else{
  219.             if(this.rest.isEnabled()==false){
  220.                 throw new MessageException("Typology ["+serviceBinding+"] not supported");
  221.             }
  222.             if(MessageRole.REQUEST.equals(messageType)){
  223.                 configurationFlow = this.rest.getRequest();
  224.             }
  225.             else{
  226.                 configurationFlow = this.rest.getResponse();
  227.             }
  228.         }

  230.         MessageType mpv = this.contextUrlCollection.getMessageType(protocol,function,functionParameters);
  231.         if(mpv!=null){
  232.             List<String> ct = this.contextUrlCollection.getContentTypesRestriction(protocol,function,functionParameters);
  233.             if(ct==null){
  234.                 ct = new ArrayList<>();
  235.             }
  236.             if(ct.size()<=0){
  237.                 ct.add(Costanti.CONTENT_TYPE_ALL);
  238.             }
  239.             return ct;
  240.         }
  241.         return configurationFlow.getContentTypes();

  243.     }
  244.     
  245.     public String getContentTypesSupportedAsString(ServiceBinding serviceBinding, MessageRole messageType, 
  246.             TransportRequestContext transportContext) throws MessageException{
  247.         return getContentTypesSupportedAsString(serviceBinding, messageType, 
  248.                 transportContext.getProtocolWebContext(), transportContext.getFunction(), transportContext.getFunctionParameters());
  249.     }
  250.     public String getContentTypesSupportedAsString(ServiceBinding serviceBinding, MessageRole messageType, 
  251.             String protocol, String function, String functionParameters) throws MessageException{
  252.         StringBuilder bf = new StringBuilder();
  253.         for (String ct : this.getContentTypesSupported(serviceBinding, messageType, 
  254.                 protocol,function,functionParameters)) {
  255.             if(bf.length()>0){
  256.                 bf.append(", ");
  257.             }
  258.             bf.append(ct);
  259.         }
  260.         return bf.toString();
  261.     }
  262.     
  263.     public MessageType getRequestMessageType(ServiceBinding serviceBinding, 
  264.             TransportRequestContext transportContext, 
  265.             String contentType) throws MessageException{
  266.         return this.getMessageType(serviceBinding, MessageRole.REQUEST, 
  267.                 transportContext.getProtocolWebContext(), transportContext.getFunction(), transportContext.getFunctionParameters(), 
  268.                 contentType, null);
  269.     }
  270.     public MessageType getResponseMessageType(ServiceBinding serviceBinding, 
  271.             TransportRequestContext transportContext, 
  272.             String contentType, Integer status) throws MessageException{
  273.         return this.getMessageType(serviceBinding, MessageRole.RESPONSE, 
  274.                 transportContext!=null ? transportContext.getProtocolWebContext() : null, 
  275.                 transportContext!=null ? transportContext.getFunction() : null, 
  276.                 transportContext!=null ? transportContext.getFunctionParameters() : null, 
  277.                 contentType, status);
  278.     }
  279.     public MessageType getMessageType(ServiceBinding serviceBinding, MessageRole messageRole, 
  280.             TransportRequestContext transportContext, 
  281.             String contentType, Integer status) throws MessageException{
  282.         return this.getMessageType(serviceBinding, messageRole, 
  283.                 transportContext.getProtocolWebContext(), transportContext.getFunction(), transportContext.getFunctionParameters(), 
  284.                 contentType, status);
  285.     }
  286.     public MessageType getMessageType(ServiceBinding serviceBinding, MessageRole messageRole, 
  287.             String protocol, String function, String functionParameters, 
  288.             String contentType, Integer status) throws MessageException{
  289.         
  290.         if(serviceBinding==null){
  291.             throw new MessageException("ServiceBinding not defined");
  292.         }
  293.         if(messageRole==null){
  294.             throw new MessageException("MessageRole not defined");
  295.         }
  296.         
  297.         String mediaType = contentType;
  298.         boolean withAttachments = false;
  299.         boolean mtom = false;
  300.         if(ServiceBinding.SOAP.equals(serviceBinding) && mediaType!=null){
  301.             try{
  302.                 if(ContentTypeUtilities.isMultipartRelated(mediaType)){
  303.                     withAttachments = true;
  304.                     String internal = ContentTypeUtilities.getInternalMultipartContentType(mediaType);
  305.                     if(internal!=null){
  306.                         mediaType = internal;
  307.                         mtom = ContentTypeUtilities.isMtom(mediaType);
  308.                         if(mtom){
  309.                             withAttachments = false;
  310.                         }
  311.                     }
  312.                 }
  313.             }catch(Exception e){
  314.                 throw new MessageException(e.getMessage(),e);
  315.             }
  316.         }
  317.         try{
  318.             if(mediaType!=null){
  319.                 ContentType ct = new ContentType(mediaType);
  320.                 mediaType = ct.getBaseType();
  321.             }
  322.         }catch(Exception e){
  323.             throw new MessageException(e.getMessage(),e);
  324.         }
  325.         
  326.         MessageType messageType = readMessageTypeEngine(serviceBinding, messageRole, 
  327.                 protocol, function, functionParameters,
  328.                 status,
  329.                 mediaType);
  330.         
  331.         // check compatibilità rispetto alla tipologia
  332.             
  333.         if(messageType!=null && ServiceBinding.SOAP.equals(serviceBinding)){
  334.             if(withAttachments){
  335.                 if(MessageType.SOAP_11.equals(messageType)){
  336.                     if(this.soap.getBinding().isBinding_soap11_withAttachments()==false){
  337.                         throw new MessageException("SOAPWithAttachments disabled in Soap11 Binding");
  338.                     }
  339.                 }
  340.                 else{
  341.                     if(this.soap.getBinding().isBinding_soap12_withAttachments()==false){
  342.                         throw new MessageException("SOAPWithAttachments disabled in Soap12 Binding");
  343.                     }
  344.                 }
  345.             }
  346.             if(mtom){
  347.                 if(MessageType.SOAP_11.equals(messageType)){
  348.                     if(this.soap.getBinding().isBinding_soap11_mtom()==false){
  349.                         throw new MessageException("MTOM disabled in Soap11 Binding");
  350.                     }
  351.                 }
  352.                 else{
  353.                     if(this.soap.getBinding().isBinding_soap12_mtom()==false){
  354.                         throw new MessageException("MTOM disabled in Soap12 Binding");
  355.                     }
  356.                 }
  357.             }
  358.         }
  359.         
  360.         return messageType;

  362.     }

  364.     private MessageType readMessageTypeEngine(ServiceBinding serviceBinding, MessageRole messageRole, 
  365.             String protocol, String function, String functionParameters,
  366.             Integer status,
  367.             String mediaType) throws MessageException {
  368.         MessageType messageType = this.contextUrlCollection.getMessageType(protocol,function,functionParameters);
  369.         if(messageType!=null){
  370.             
  371.             // check sulla restrizione dei content-type
  372.             List<String> ct = this.contextUrlCollection.getContentTypesRestriction(protocol,function,functionParameters);
  373.             if(ct!=null && ct.size()>0){
  374.                 if(mediaType!=null && ct.contains(mediaType)){
  375.                     return messageType;
  376.                 }
  377.             }
  378.             else{
  379.                 return messageType; 
  380.             }
  381.             
  382.         }
  383.         
  384.         AbstractMediaTypeCollection mediaTypeCollecton;

  386.         if(ServiceBinding.SOAP.equals(serviceBinding)){
  387.             if(this.soap.isEnabled()==false){
  388.                 throw new MessageException("Typology ["+serviceBinding+"] not supported");
  389.             }
  390.             if(MessageRole.REQUEST.equals(messageRole)){
  391.                 mediaTypeCollecton = this.soap.getRequest();
  392.             }
  393.             else{
  394.                 mediaTypeCollecton = this.soap.getResponse();
  395.             }
  396.         }
  397.         else{
  398.             if(this.rest.isEnabled()==false){
  399.                 throw new MessageException("Typology ["+serviceBinding+"] not supported");
  400.             }
  401.             if(MessageRole.REQUEST.equals(messageRole)){
  402.                 mediaTypeCollecton = this.rest.getRequest();
  403.             }
  404.             else{
  405.                 mediaTypeCollecton = this.rest.getResponse();
  406.             }
  407.         }
  408.                 
  409.         messageType = mediaTypeCollecton.getMessageProcessor(mediaType,status); // può essere null
  410.         return messageType;
  411.     }
  412. }
Created with JaCoCo 0.8.8.202204050719