URLProtocolContextImpl.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.protocol.engine;

  23. import javax.servlet.http.HttpServletRequest;

  25. import org.openspcoop2.protocol.manifest.constants.Costanti;
  26. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  27. import org.openspcoop2.protocol.sdk.ProtocolException;
  28. import org.openspcoop2.protocol.sdk.constants.IDService;
  29. import org.openspcoop2.protocol.sdk.state.FunctionContextsCustom;
  30. import org.openspcoop2.utils.UtilsException;
  31. import org.slf4j.Logger;

  33. /**
  34.  * URL Protocol Context
  35.  *
  36.  * @author Poli Andrea (apoli@link.it)
  37.  * @author $Author$
  38.  * @version $Rev$, $Date$
  39.  */


  42. public class URLProtocolContextImpl extends org.openspcoop2.protocol.sdk.state.URLProtocolContext implements java.io.Serializable {


  45.     /**
  46.      * 
  47.      */
  48.     private static final long serialVersionUID = 1L;
  49.     
  50.     public URLProtocolContextImpl(Logger logCore) throws UtilsException{
  51.         super(logCore);
  52.     }
  53.     public URLProtocolContextImpl(HttpServletRequest req,Logger logCore, boolean debug, FunctionContextsCustom customContexts) throws ProtocolException, UtilsException{
  54.         super(req, logCore, debug, customContexts);
  55.     }
  56.     public URLProtocolContextImpl(HttpServletRequest req,Logger logCore, boolean debug, boolean integrationManagerEngine, FunctionContextsCustom customContexts) throws ProtocolException, UtilsException{
  57.         super(req, logCore, debug, integrationManagerEngine, customContexts);
  58.     }
  59.     
  60.     @Override
  61.     protected void init(HttpServletRequest req,Logger logCore, boolean debug, boolean integrationManagerEngine, FunctionContextsCustom customContexts) throws ProtocolException, UtilsException{
  62.                 
  63.         String servletContext = req.getContextPath();
  64.         String urlInvocazione = req.getRequestURI();
  65.         String servizioInvocato = null;
  66.         if(logCore!=null)
  67.             logCore.debug("SERVLET CONTEXT ["+servletContext+"] URL["+urlInvocazione+"]");
  68.             // es SERVLET CONTEXT [/govway] URL[/govway/altriParametri]
  69.         try {
  70.             
  71.             ProtocolFactoryManager protocolFactoryManager = ProtocolFactoryManager.getInstance();
  72.             IProtocolFactory<?> pfEmptyContext = null;
  73.             IDService idServiceDefaultEmptyContext = null;
  74.             try {
  75.                 pfEmptyContext = protocolFactoryManager.getProtocolFactoryWithEmptyContext();
  76.                 idServiceDefaultEmptyContext = protocolFactoryManager.getDefaultServiceForEmptyContext();
  77.             }catch(Throwable e) {
  78.                 // ignore
  79.             }
  80.             
  81.             // Altro...
  82.             if(urlInvocazione.startsWith(servletContext+"/")){
  83.                 servizioInvocato = urlInvocazione.substring((servletContext+"/").length());
  84.             }
  85.             else if(urlInvocazione.equals(servletContext)){
  86.                 servizioInvocato = null;
  87.             }
  88.             else {
  89.                 throw new Exception("GovWay [protocol/]service to be used not supplied (context error)");
  90.             }
  91.             
  92.             
  93.             if(logCore!=null)
  94.                 logCore.debug("SERVIZIO RICHIESTO: ["+servizioInvocato+"]");
  95.             
  96.             // verifico che dopo "openspcoop2" sia stato fornito qualcosa
  97.             if(servizioInvocato==null || "".equals(servizioInvocato.trim())){
  98.                 if(pfEmptyContext!=null && idServiceDefaultEmptyContext!=null) {
  99.                     this.protocolName = pfEmptyContext.getProtocol();
  100.                     this.idServiceCustom = idServiceDefaultEmptyContext;
  101.                     switch (idServiceDefaultEmptyContext) {
  102.                     case PORTA_DELEGATA:
  103.                         this.function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PD_FUNCTION_GOVWAY;
  104.                         break;
  105.                     case PORTA_APPLICATIVA:
  106.                         this.function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PA_FUNCTION_GOVWAY;
  107.                         break;
  108.                     case PORTA_DELEGATA_XML_TO_SOAP:
  109.                         this.function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PDtoSOAP_FUNCTION_GOVWAY;
  110.                         break;
  111.                     default:
  112.                         throw new Exception("GovWay [protocol/]service to be used not supplied");
  113.                     }
  114.                     this.functionParameters = servizioInvocato;
  115.                     this.protocolWebContext = Costanti.CONTEXT_EMPTY;
  116.                 }
  117.                 else {
  118.                     throw new Exception("GovWay [protocol/]service to be used not supplied");
  119.                 }
  120.             }
  121.             else {
  122.             
  123.                 // Esamino il servizio fornito. Puo' darsi che prima del servizio ci sia il protocollo.
  124.                 String protocollo = null;
  125.                 String function = null;
  126.                 String functionParameters = null;
  127.                 if(servizioInvocato.indexOf("/") >= 0){
  128.                     protocollo = servizioInvocato.substring(0,servizioInvocato.indexOf("/"));
  129.                     function = servizioInvocato.substring(servizioInvocato.indexOf("/")+1,servizioInvocato.length());
  130.                 }else{
  131.                     protocollo = servizioInvocato;
  132.                     function = servizioInvocato;
  133.                 }
  134.                 if(logCore!=null)
  135.                     logCore.debug("PROTOCOLLO["+protocollo+"] FUNCTION["+function+"]");
  136.                 
  137.                 // Vedo se ho un protocollo prima della funzione o direttamente il protocollo
  138.                 boolean IMengine = false;
  139.                 if(integrationManagerEngine && protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.IntegrationManager_ENGINE)) {
  140.                     if(logCore!=null)
  141.                         logCore.debug("SERVLET INTEGRATION MANAGER SERVICE");
  142.                     function = protocollo;
  143.                     
  144.                     IMengine = true;
  145.                     
  146.                     Object o = getHttpServletRequest().getAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue());
  147.                     if(o == null || !(o instanceof String)){
  148.                         throw new Exception("Indicazione del protocollo non presente");
  149.                     }
  150.                     this.protocolName = (String) o;
  151.                     IProtocolFactory<?> pf = protocolFactoryManager.getProtocolFactoryByName(this.protocolName);
  152.                     if(pf==null){
  153.                         throw new Exception("Non risulta registrato un protocollo con nome ["+this.protocolName+"]");
  154.                     }
  155.                     
  156.                     o = getHttpServletRequest().getAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_WEB_CONTEXT.getValue());
  157.                     if(o == null || !(o instanceof String)){
  158.                         throw new Exception("Indicazione del web context del protocollo non presente");
  159.                     }
  160.                     this.protocolWebContext = (String) o;
  161.                     pf = protocolFactoryManager.getProtocolFactoryByServletContext(this.protocolWebContext);
  162.                     if(pf==null){
  163.                         if(!Costanti.CONTEXT_EMPTY.equals(this.protocolWebContext))
  164.                             throw new Exception("Non risulta registrato un protocollo con contesto ["+this.protocolWebContext+"]");
  165.                         else
  166.                             throw new Exception("Non risulta registrato un protocollo con contesto speciale 'vuoto'");
  167.                     }
  168.                     
  169.                     int sizePrefix = (req.getContextPath() + "/" + function + "/").length();
  170.                     if(req.getRequestURI().length()>sizePrefix){
  171.                         functionParameters = req.getRequestURI().substring(sizePrefix);
  172.                     }
  173.                     
  174.                     if(functionParameters!=null && functionParameters.startsWith(IntegrationManager_SERVICE_PD)) {
  175.                         function+="_"+IntegrationManager_SERVICE_PD;
  176.                         
  177.                         Object oPD = getHttpServletRequest().getAttribute(org.openspcoop2.core.constants.Costanti.PORTA_DELEGATA.getValue());
  178.                         if(oPD == null || !(oPD instanceof String)){
  179.                             throw new Exception("Indicazione della porta delegata non presente");
  180.                         }
  181.                         
  182.                         functionParameters=(String)oPD;
  183.                         
  184.                     } 
  185.                     else if(functionParameters!=null && functionParameters.startsWith(IntegrationManager_SERVICE_MessageBox)) {
  186.                         function+="_"+IntegrationManager_SERVICE_MessageBox;
  187.                         
  188.                         if(functionParameters.length()>IntegrationManager_SERVICE_MessageBox.length()) {
  189.                             functionParameters = functionParameters.substring(IntegrationManager_SERVICE_MessageBox.length());
  190.                         }
  191.     //                  else {
  192.     //                      functionParameters = null;
  193.     //                  }
  194.                     }
  195.                 }
  196.                 else if(protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PA_FUNCTION) || 
  197.                         protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PD_FUNCTION) || 
  198.                         protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PDtoSOAP_FUNCTION) || 
  199.                         protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.IntegrationManager_FUNCTION) ||
  200.                         protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.Check_FUNCTION) ||
  201.                         protocollo.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.Proxy_FUNCTION) ||
  202.                         (customContexts!=null && customContexts.isMatch(protocollo, function))) {
  203.                     // ContextProtocol Empty
  204.                     if(logCore!=null)
  205.                         logCore.debug("SERVLET PATH EMPTY");
  206.                     if((customContexts!=null && customContexts.isMatch(protocollo, function))) {
  207.                         this.idServiceCustom = customContexts.getServiceMatch(protocollo, function);
  208.                         function = customContexts.getFunctionMatch(protocollo, function);
  209.                         if(logCore!=null)
  210.                             logCore.debug("CUSTOM FUNCTION ["+function+"] ["+this.idServiceCustom+"]");
  211.                     }
  212.                     else {
  213.                         function = protocollo;
  214.                     }
  215.                     protocollo = Costanti.CONTEXT_EMPTY;
  216.                     
  217.                     int sizePrefix = (req.getContextPath() + "/" + function + "/").length();
  218.                     if(req.getRequestURI().length()>sizePrefix){
  219.                         functionParameters = req.getRequestURI().substring(sizePrefix);
  220.                     }
  221.                     else {
  222.                         // Serve nei casi custom
  223.                         functionParameters = null;
  224.                     }
  225.                 }
  226.                 else{
  227.                     // Verifico se esiste o meno il protocollo tra quelli registrati
  228.                     boolean casoSpeciale_noProtocollo_noFunction = false;
  229.                     try {
  230.                         IProtocolFactory<?> pfCheck = protocolFactoryManager.getProtocolFactoryByServletContext(protocollo);
  231.                         if(pfCheck==null) {
  232.                             throw new Exception("NotFound");
  233.                         }
  234.                     }catch(Exception e) {
  235.                         if(pfEmptyContext!=null) {
  236.                             if(function!=null && !"".equals(function)) {
  237.                                 function = protocollo + "/" + function;
  238.                             }
  239.                             else {
  240.                                 function = protocollo;
  241.                             }
  242.                             protocollo = Costanti.CONTEXT_EMPTY;
  243.                             casoSpeciale_noProtocollo_noFunction = true;
  244.                         }
  245.                     }
  246.                         
  247.                     
  248.                     // Calcolo function
  249.                     String functionParameterForCheckCustom = null;
  250.                     if(function.indexOf("/") > 0){
  251.                         functionParameterForCheckCustom = function.substring(function.indexOf("/"));
  252.                         if(functionParameterForCheckCustom.length()>1 && functionParameterForCheckCustom.startsWith("/")) {
  253.                             functionParameterForCheckCustom = functionParameterForCheckCustom.substring(1);
  254.                         }
  255.                     }
  256.                     if(function.indexOf("/") > 0){
  257.                         function = function.substring(0,function.indexOf("/"));
  258.                     }
  259.                     else if(function.indexOf("?") > 0){
  260.                         function = function.substring(0,function.indexOf("?"));
  261.                     }
  262.                     if(logCore!=null)
  263.                         logCore.debug("FUNCTION ["+function+"]");
  264.                     
  265.                     boolean emptyFunction = false;
  266.                     if(casoSpeciale_noProtocollo_noFunction ||
  267.                             (
  268.                                     ! (function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PA_FUNCTION) || 
  269.                                             function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PD_FUNCTION) || 
  270.                                             function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.PDtoSOAP_FUNCTION) || 
  271.                                             function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.IntegrationManager_FUNCTION) ||
  272.                                             function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.Check_FUNCTION) ||
  273.                                             function.equals(org.openspcoop2.protocol.sdk.state.URLProtocolContext.Proxy_FUNCTION) ||
  274.                                         (customContexts!=null && customContexts.isMatch(function, functionParameterForCheckCustom))) 
  275.                                     )
  276.                             ){
  277.                         IDService idS = null;
  278.                         if(casoSpeciale_noProtocollo_noFunction) {
  279.                             if(pfEmptyContext!=null && idServiceDefaultEmptyContext!=null) {
  280.                                 idS = idServiceDefaultEmptyContext;                         
  281.                             }
  282.                         }
  283.                         else {
  284.                             idS = protocolFactoryManager.getDefaultServiceForWebContext(protocollo);
  285.                         }
  286.                         if(idS!=null) {
  287.                             this.protocolName = pfEmptyContext.getProtocol();
  288.                             this.idServiceCustom = idS;
  289.                             switch (idS) {
  290.                             case PORTA_DELEGATA:
  291.                                 function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PD_FUNCTION_GOVWAY;
  292.                                 emptyFunction = true;
  293.                                 break;
  294.                             case PORTA_APPLICATIVA:
  295.                                 function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PA_FUNCTION_GOVWAY;
  296.                                 emptyFunction = true;
  297.                                 break;
  298.                             case PORTA_DELEGATA_XML_TO_SOAP:
  299.                                 function = org.openspcoop2.protocol.sdk.state.URLProtocolContext.PDtoSOAP_FUNCTION_GOVWAY;
  300.                                 emptyFunction = true;
  301.                                 break;
  302.                             default:
  303.                             }
  304.                         }
  305.                     }
  306.                     
  307.                     StringBuilder bfSizePrefix = new StringBuilder(req.getContextPath());
  308.                     if(!Costanti.CONTEXT_EMPTY.equals(protocollo)) {
  309.                         bfSizePrefix.append("/").append(protocollo);
  310.                     }
  311.                     if(!emptyFunction) {
  312.                         bfSizePrefix.append("/").append(function);
  313.                     }
  314.                     bfSizePrefix.append("/");
  315.                     
  316.                     int sizePrefix = bfSizePrefix.length();
  317.                     if(req.getRequestURI().length()>sizePrefix){
  318.                         functionParameters = req.getRequestURI().substring(sizePrefix);
  319.                     }
  320.                     else {
  321.                         // Serve nei casi custom
  322.                         functionParameters = null;
  323.                     }
  324.                     
  325.                     if(!casoSpeciale_noProtocollo_noFunction && !emptyFunction) {
  326.                         if((customContexts!=null && customContexts.isMatch(function, functionParameters))) {
  327.                             this.idServiceCustom = customContexts.getServiceMatch(function, functionParameters);
  328.                             function = customContexts.getFunctionMatch(function, functionParameters);
  329.                             if(logCore!=null)
  330.                                 logCore.debug("CUSTOM FUNCTION ["+function+"] ["+this.idServiceCustom+"]");
  331.                             // ricalcolo function parameters
  332.                             sizePrefix = (req.getContextPath() + "/"+ protocollo + "/" + function + "/").length();
  333.                             if(req.getRequestURI().length()>sizePrefix){
  334.                                 functionParameters = req.getRequestURI().substring(sizePrefix);
  335.                             }
  336.                             else {
  337.                                 // Serve nei casi custom
  338.                                 functionParameters = null;
  339.                             }
  340.                         }
  341.                     }
  342.                     
  343.                     if(casoSpeciale_noProtocollo_noFunction && emptyFunction) {
  344.                         this.requestURI = this.requestURI.replace(servletContext+"/", servletContext+"/"+function+"/");
  345.                     }
  346.                     else if(emptyFunction) {
  347.                         this.requestURI = this.requestURI.replace(servletContext+"/"+protocollo+"/", servletContext+"/"+protocollo+"/"+function+"/");
  348.                     }
  349.                 }
  350.                                         
  351.                 if(logCore!=null)
  352.                     logCore.debug("Elaborazione finale Protocollo["+protocollo+"] Function["+function+"] FunctionParameters ["+functionParameters+"]");
  353.                 
  354.                 if(!IMengine) {
  355.                     this.protocolWebContext = protocollo;
  356.                     IProtocolFactory<?> pf = protocolFactoryManager.getProtocolFactoryByServletContext(this.protocolWebContext);
  357.                     if(pf==null){
  358.                         if(!Costanti.CONTEXT_EMPTY.equals(this.protocolWebContext))
  359.                             throw new Exception("Non risulta registrato un protocollo con contesto ["+this.protocolWebContext+"]");
  360.                         else
  361.                             throw new Exception("Non risulta registrato un protocollo con contesto speciale 'vuoto'");
  362.                     }
  363.                     this.protocolName = pf.getProtocol();
  364.                 }
  365.     
  366.                 this.function = function;
  367.                 this.functionParameters = functionParameters;
  368.                 
  369.             }
  370.             
  371.         }catch(Exception e){
  372.             throw new ProtocolException(e.getMessage(),e);
  373.         }
  374.     }
  375.     
  376.     @Override
  377.     public String toString() {
  378.         return this.toString("");
  379.     }
  380.     @Override
  381.     public String toString(String prefix) {
  382.         StringBuilder sb = new StringBuilder(super.toString(prefix));
  383.         if(this.idServiceCustom!=null) {
  384.             sb.append("\n").append(prefix).append("idServiceCustom: ").append(this.idServiceCustom);
  385.         }
  386.         return sb.toString();
  387.     }
  388. }
Created with JaCoCo 0.8.8.202204050719