OpenSPCoop2Servlet.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.services.connector;

  23. import java.io.IOException;
  24. import java.util.Enumeration;

  26. import javax.servlet.RequestDispatcher;
  27. import javax.servlet.ServletException;
  28. import javax.servlet.http.HttpServlet;
  29. import javax.servlet.http.HttpServletRequest;
  30. import javax.servlet.http.HttpServletResponse;

  32. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  33. import org.openspcoop2.pdd.core.CostantiPdD;
  34. import org.openspcoop2.pdd.core.byok.BYOKMapProperties;
  35. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  36. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  37. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  38. import org.openspcoop2.protocol.engine.URLProtocolContextImpl;
  39. import org.openspcoop2.protocol.manifest.constants.Costanti;
  40. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  41. import org.openspcoop2.protocol.sdk.constants.IDService;
  42. import org.openspcoop2.protocol.sdk.state.FunctionContextsCustom;
  43. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  44. import org.openspcoop2.utils.LoggerWrapperFactory;
  45. import org.openspcoop2.utils.Semaphore;
  46. import org.openspcoop2.utils.SemaphoreLock;
  47. import org.openspcoop2.utils.Utilities;
  48. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  49. import org.slf4j.Logger;

  51. /**
  52.  * OpenSPCoop2Servlet
  53.  * 
  54.  * @author Poli Andrea (apoli@link.it)
  55.  * @author $Author$
  56.  * @version $Rev$, $Date$
  57.  */
  58. @SuppressWarnings("serial")
  59. public class OpenSPCoop2Servlet extends HttpServlet {
  60.     private static Logger logger = null;

  62.     private static synchronized Logger _getLogger() {
  63.         if ( logger == null ) {
  64.             logger = LoggerWrapperFactory.getLogger("govway.startup");
  65.         }
  66.         return logger;
  67.     }
  68.     private static Logger getLogger() {
  69.         if ( logger == null )
  70.             _getLogger();
  71.         return logger;
  72.     }

  74.     private static boolean checkSecrets = false;
  75.     private static final Semaphore semaphoreCheckSecrets = new Semaphore("GovWaySecrets");
  76.     private static void checkSecrets() {
  77.         if(!checkSecrets) {
  78.             initSecrets();
  79.         }
  80.     }
  81.     private static void initSecrets() {
  82.         SemaphoreLock lock = semaphoreCheckSecrets.acquireThrowRuntime("initSecrets");
  83.         try {
  84.             if(!checkSecrets) {
  85.                 BYOKMapProperties secretsProperties = BYOKMapProperties.getInstance();
  86.                 if(secretsProperties!=null && secretsProperties.isExistsUnwrapPropertiesAfterGovWayStartup()) {
  87.                     secretsProperties.setGovWayStarted(true);
  88.                     try {
  89.                         secretsProperties.initEnvironment();
  90.                         String secretsConfig = OpenSPCoop2Properties.getInstance().getBYOKEnvSecretsConfig();
  91.                         String msgInit = "Environment inizializzato con i secrets definiti nel file '"+secretsConfig+"' dopo il completamento dell'avvio di GovWay"+
  92.                                 "\n\tJavaProperties: "+secretsProperties.getJavaMap().keys()+
  93.                                 "\n\tEnvProperties: "+secretsProperties.getEnvMap().keys()+
  94.                                 "\n\tObfuscateMode: "+secretsProperties.getObfuscateModeDescription();
  95.                         OpenSPCoop2Startup.logStartupInfo(msgInit);
  96.                     } catch (Exception e) {
  97.                         OpenSPCoop2Startup.logStartupError("Inizializzazione ambiente (secrets) non riuscita: "+e.getMessage(),e);
  98.                     }
  99.                 }
  100.                 checkSecrets = true;
  101.             }
  102.         }finally {
  103.             semaphoreCheckSecrets.release(lock, "initSecrets");
  104.         }
  105.     }
  106.     
  107.     @Override
  108.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  109.                 
  110.         HttpRequestMethod m = null;
  111.         try {
  112.             m = HttpRequestMethod.valueOf(req.getMethod().toUpperCase());
  113.         }catch(Exception e) {
  114.             super.service(req, resp); // richiamo implementazione originale che genera errore: Method XXX is not defined in RFC 2068 and is not supported by the Servlet API
  115.             return;
  116.         }
  117.         switch (m) {
  118.         
  119.         // Standard
  120.         
  121.         case DELETE:
  122.             this.doDelete(req, resp);
  123.             break;
  124.         case GET:
  125.             this.doGet(req, resp);
  126.             break;
  127.         case HEAD:
  128.             this.doHead(req, resp);
  129.             break;
  130.         case OPTIONS:
  131.             this.doOptions(req, resp);
  132.             break;
  133.         case POST:
  134.             this.doPost(req, resp);
  135.             break;
  136.         case PUT:
  137.             this.doPut(req, resp);
  138.             break;
  139.         case TRACE:
  140.             this.doTrace(req, resp);
  141.             break;
  142.             
  143.         // Additionals
  144.         case PATCH:
  145.         case LINK:
  146.         case UNLINK:
  147.             boolean enabled = true;
  148.             OpenSPCoop2Properties op2Properties = null;
  149.             try {
  150.                 op2Properties = OpenSPCoop2Properties.getInstance();
  151.             }catch(Throwable t) { 
  152.                 //come default si lasciano abilitati
  153.             }
  154.             if(op2Properties!=null) {
  155.                 if(HttpRequestMethod.PATCH.equals(m)) {
  156.                     enabled = op2Properties.isServiceRequestHttpMethodPatchEnabled();
  157.                 }
  158.                 else if(HttpRequestMethod.LINK.equals(m)) {
  159.                     enabled = op2Properties.isServiceRequestHttpMethodLinkEnabled();
  160.                 }
  161.                 else if(HttpRequestMethod.UNLINK.equals(m)) {
  162.                     enabled = op2Properties.isServiceRequestHttpMethodUnlinkEnabled();
  163.                 }
  164.             }
  165.             if(enabled) {
  166.                 dispatch(req, resp, m);
  167.             }
  168.             else {
  169.                 super.service(req, resp); // richiamo implementazione originale che genera errore: Method XXX is not defined in RFC 2068 and is not supported by the Servlet API
  170.             }
  171.             break;
  172.             
  173.         default:
  174.             super.service(req, resp); // richiamo implementazione originale che genera errore: Method XXX is not defined in RFC 2068 and is not supported by the Servlet API
  175.             break;
  176.         }
  177.     }

  179.     @Override
  180.     protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
  181.             throws ServletException, IOException {
  182.         dispatch(req, resp, HttpRequestMethod.DELETE);
  183.     }

  185.     @Override
  186.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  187.             throws ServletException, IOException {
  188.         dispatch(req, resp, HttpRequestMethod.GET);
  189.     }

  191.     @Override
  192.     protected void doHead(HttpServletRequest req, HttpServletResponse resp)
  193.             throws ServletException, IOException {
  194.         dispatch(req, resp, HttpRequestMethod.HEAD);
  195.     }

  197.     @Override
  198.     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
  199.             throws ServletException, IOException {
  200.         dispatch(req, resp, HttpRequestMethod.OPTIONS);
  201.     }

  203.     @Override
  204.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
  205.             throws ServletException, IOException {
  206.         dispatch(req, resp, HttpRequestMethod.POST);
  207.     }

  209.     @Override
  210.     protected void doPut(HttpServletRequest req, HttpServletResponse resp)
  211.             throws ServletException, IOException {
  212.         dispatch(req, resp, HttpRequestMethod.PUT);
  213.     }

  215.     @Override
  216.     protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
  217.             throws ServletException, IOException {
  218.         dispatch(req, resp, HttpRequestMethod.TRACE);
  219.     }

  221.     
  222.     private void dispatch(HttpServletRequest req, HttpServletResponse res,HttpRequestMethod method) {
  223.         
  224.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  225.         Logger logOpenSPCoop2Servlet = getLogger();
  226.         
  227.         OpenSPCoop2Properties op2Properties = null;
  228.         try {
  229.             
  230.             if (!OpenSPCoop2Startup.initialize) {
  231.                 
  232.                 // req.getContextPath()[/govway] req.getRequestURI()[/govway/check]
  233.                 String contextPath = req.getContextPath();
  234.                 String requestUri = req.getRequestURI();
  235.                 if(requestUri!=null && contextPath!=null && requestUri.startsWith(contextPath) && requestUri.length()>contextPath.length()) {
  236.                     String function = requestUri.substring(contextPath.length(), requestUri.length());
  237.                     if(function.startsWith("/") && function.length()>1) {
  238.                         function = function.substring(1);
  239.                     }
  240.                     if(function.equals(URLProtocolContext.Check_FUNCTION) || function.equals(URLProtocolContext.Proxy_FUNCTION)){
  241.                         CheckStatoPdD.serializeNotInitializedResponse(res, (logCore!=null) ? logCore : logOpenSPCoop2Servlet);
  242.                         return;
  243.                     }
  244.                 }
  245.                 
  246.                 // Attendo inizializzazione
  247.                 int max = CostantiPdD.WAIT_STARTUP_TIMEOUT_SECONDS;
  248.                 int sleepCheck = CostantiPdD.WAIT_STARTUP_CHECK_INTERVAL_MS;
  249.                 for (int i = 0; i < 5; i++) { // attendo 5 secondi la presenza delle proprietà
  250.                     if(OpenSPCoop2Properties.getInstance()==null) {
  251.                         Utilities.sleep(1000);
  252.                     }
  253.                     if(OpenSPCoop2Properties.getInstance()!=null) {
  254.                         break;
  255.                     }
  256.                 }
  257.                 if(OpenSPCoop2Properties.getInstance()!=null) {
  258.                     max = OpenSPCoop2Properties.getInstance().getStartupRichiesteIngressoTimeoutSecondi();
  259.                     sleepCheck = OpenSPCoop2Properties.getInstance().getStartupRichiesteIngressoCheckMs();
  260.                 }
  261.                 
  262.                 int maxMs = (max * 1000);
  263.                 int actualMs = 0;
  264.                 while(!OpenSPCoop2Startup.initialize && actualMs<maxMs) {
  265.                     Utilities.sleep(sleepCheck);
  266.                     actualMs = actualMs + sleepCheck;
  267.                 }
  268.                 
  269.                 if (!OpenSPCoop2Startup.initialize) {
  270.                 
  271.                     // log su file core
  272.                     StringBuilder bfLogError = new StringBuilder();
  273.                     ConnectorUtils.generateErrorMessage(IDService.OPENSPCOOP2_SERVLET,method,req,bfLogError, "GovWay non inizializzato", true, false);
  274.                     if(logCore!=null){
  275.                         logCore.error(bfLogError.toString());
  276.                     }
  277.                     else{
  278.                         logOpenSPCoop2Servlet.error(bfLogError.toString());
  279.                     }
  280.                     res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeGovWayNotInitialized(IDService.OPENSPCOOP2_SERVLET)));
  281.                     return;
  282.                     
  283.                 }
  284.             }
  285.             op2Properties = OpenSPCoop2Properties.getInstance();
  286.             
  287.             boolean printCertificate = false;
  288.             FunctionContextsCustom customContexts = null;
  289.             if(op2Properties!=null) {
  290.                 printCertificate = op2Properties.isPrintInfoCertificate();
  291.                 customContexts = op2Properties.getCustomContexts();
  292.             }
  293.             
  294.             URLProtocolContext protocolContext = new URLProtocolContextImpl(req, logCore, printCertificate, customContexts);
  295.             String function = protocolContext.getFunction();
  296.             IDService idServiceCustom = protocolContext.getIdServiceCustom();
  297.             
  298.             IProtocolFactory<?> pf = ProtocolFactoryManager.getInstance().getProtocolFactoryByServletContext(protocolContext.getProtocolWebContext());
  299.             if(pf==null){
  300.                 if(!Costanti.CONTEXT_EMPTY.equals(protocolContext.getProtocolWebContext()))
  301.                     throw new Exception("Non risulta registrato un protocollo con contesto ["+protocolContext.getProtocolWebContext()+"]");
  302.                 else
  303.                     throw new Exception("Non risulta registrato un protocollo con contesto speciale 'vuoto'");
  304.             }
  305.                         
  306.             if( 
  307.                     (function.equals(URLProtocolContext.PD_FUNCTION) && op2Properties.isEnabledFunctionPD()) 
  308.                     || 
  309.                     (idServiceCustom!=null && IDService.PORTA_DELEGATA.equals(idServiceCustom))
  310.                 ){
  311.                 
  312.                 checkSecrets();
  313.                 
  314.                 RicezioneContenutiApplicativiConnector r = new RicezioneContenutiApplicativiConnector();
  315.                 r.doEngine(ConnectorUtils.getRequestInfo(pf, protocolContext), req, res, method);
  316.                 
  317.             }
  318.             else if(
  319.                     (function.equals(URLProtocolContext.PDtoSOAP_FUNCTION) && op2Properties.isEnabledFunctionPDtoSOAP()) 
  320.                     || 
  321.                     (idServiceCustom!=null && IDService.PORTA_DELEGATA_XML_TO_SOAP.equals(idServiceCustom))
  322.                 ){
  323.                 
  324.                 checkSecrets();
  325.                 
  326.                 RicezioneContenutiApplicativiHTTPtoSOAPConnector r = new RicezioneContenutiApplicativiHTTPtoSOAPConnector();
  327.                 r.doEngine(ConnectorUtils.getRequestInfo(pf, protocolContext), req, res, method);
  328.                 
  329.             }
  330.             else if(
  331.                     (function.equals(URLProtocolContext.PA_FUNCTION) && op2Properties.isEnabledFunctionPA()) 
  332.                     || 
  333.                     (idServiceCustom!=null && IDService.PORTA_APPLICATIVA.equals(idServiceCustom))
  334.                 ){
  335.                 
  336.                 checkSecrets();
  337.                 
  338.                 RicezioneBusteConnector r = new RicezioneBusteConnector();
  339.                 r.doEngine(ConnectorUtils.getRequestInfo(pf, protocolContext), req, res, method);
  340.             }
  341.             
  342.             else if(function.equals(URLProtocolContext.IntegrationManager_FUNCTION) || (idServiceCustom!=null && IDService.INTEGRATION_MANAGER_SOAP.equals(idServiceCustom))){
  343.                 
  344.                 checkSecrets();
  345.                 
  346.                 if(op2Properties!=null && op2Properties.isIntegrationManagerEnabled()==false) {
  347.                     throw new Exception("Service ["+function+"] not active");
  348.                 }
  349.                 
  350.                 boolean wsdl = false;
  351.                 if(HttpRequestMethod.GET.equals(method)){
  352.                     Enumeration<?> parameters = req.getParameterNames();
  353.                     while(parameters.hasMoreElements()){
  354.                         String key = (String) parameters.nextElement();
  355.                         String value = req.getParameter(key);
  356.                         if("wsdl".equalsIgnoreCase(key) && (value==null || "".equals(value)) ){
  357.                             // richiesta del wsdl
  358.                             if(op2Properties!=null && op2Properties.isGenerazioneWsdlIntegrationManagerEnabled()==false){
  359.                                 res.sendError(404, ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeWsdlUnsupported(IDService.INTEGRATION_MANAGER_SOAP)));
  360.                                 return;
  361.                             }
  362.                             else{
  363.                                 wsdl = true;
  364.                                 break;
  365.                             }
  366.                         }
  367.                     }
  368.                 }
  369.                 
  370.                 if(!HttpRequestMethod.POST.equals(method) && !wsdl){
  371.                     // messaggio di errore
  372.                     boolean errore404 = false;
  373.                     if(op2Properties!=null && !op2Properties.isGenerazioneErroreHttpMethodUnsupportedIntegrationManagerEnabled()){
  374.                         errore404 = true;
  375.                     }
  376.                     
  377.                     if(errore404){
  378.                         res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeHttpMethodNotSupported(IDService.INTEGRATION_MANAGER_SOAP, method)));
  379.                         return;
  380.                     }
  381.                     else{
  382.                     
  383.                         res.setStatus(500);
  384.                         
  385.                         ConnectorUtils.generateErrorMessage(IDService.INTEGRATION_MANAGER_SOAP, method, req, res, ConnectorUtils.getMessageHttpMethodNotSupported(method), false, true);
  386.                                 
  387.                         try{
  388.                             res.getOutputStream().flush();
  389.                         }catch(Exception eClose){
  390.                             // ignore
  391.                         }
  392.                         try{
  393.                             res.getOutputStream().close();
  394.                         }catch(Exception eClose){
  395.                             // ignore
  396.                         }
  397.                         
  398.                         return;
  399.                     }
  400.                 }
  401.                                 
  402.                 // Dispatching al servizio di IntegrationManager implementato tramite CXF
  403.                 String serviceIM = protocolContext.getFunctionParameters();
  404.                 if(URLProtocolContext.IntegrationManager_SERVICE_PD_GOVWAY.equals(serviceIM) || 
  405.                         (URLProtocolContext.IntegrationManager_SERVICE_PD_GOVWAY+"/").equals(serviceIM)) {
  406.                     serviceIM = URLProtocolContext.IntegrationManager_SERVICE_PD;
  407.                 }
  408.                 String forwardUrl = "/"+URLProtocolContext.IntegrationManager_ENGINE+"/"+serviceIM;
  409.                 req.setAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue(), protocolContext.getProtocolName());
  410.                 req.setAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_WEB_CONTEXT.getValue(), protocolContext.getProtocolWebContext());
  411.                 req.setAttribute(org.openspcoop2.core.constants.Costanti.INTEGRATION_MANAGER_ENGINE_AUTHORIZED.getValue(), true);
  412.                 RequestDispatcher dispatcher = req.getRequestDispatcher(forwardUrl);
  413.                 dispatcher.forward(req, res);
  414.                 
  415.             }
  416.             else if(function.equals(URLProtocolContext.Check_FUNCTION)){
  417.                 
  418.                 if(HttpRequestMethod.GET.equals(method)==false){
  419.                     // messaggio di errore
  420.                     boolean errore404 = false;
  421.                     if(op2Properties!=null && !op2Properties.isGenerazioneErroreHttpMethodUnsupportedCheckEnabled()){
  422.                         errore404 = true;
  423.                     }
  424.                     
  425.                     if(errore404){
  426.                         res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeHttpMethodNotSupported(IDService.CHECK_PDD, method)));
  427.                         return;
  428.                     }
  429.                     else{
  430.                         
  431.                         res.setStatus(500);
  432.                         
  433.                         ConnectorUtils.generateErrorMessage(IDService.CHECK_PDD,method,req,res, ConnectorUtils.getMessageHttpMethodNotSupported(method), false, true);
  434.                                 
  435.                         try{
  436.                             res.getOutputStream().flush();
  437.                         }catch(Exception eClose){
  438.                             // ignore
  439.                         }
  440.                         try{
  441.                             res.getOutputStream().close();
  442.                         }catch(Exception eClose){
  443.                             // ignore
  444.                         }
  445.                         
  446.                         return;
  447.                     }
  448.                 }
  449.                 
  450.                 // Dispatching al servizio 
  451.                 CheckStatoPdD checkStatoPdD = new CheckStatoPdD();
  452.                 req.setAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue(), protocolContext.getProtocolName());
  453.                 checkStatoPdD.doGet(req, res);
  454.                 
  455.             }
  456.             else if(function.equals(URLProtocolContext.Proxy_FUNCTION)){
  457.                 
  458.                 if(op2Properties!=null && !op2Properties.isProxyReadJMXResourcesEnabled()) {
  459.                     throw new Exception("Service ["+function+"] not supported");
  460.                 }
  461.                 
  462.                 if(HttpRequestMethod.GET.equals(method)==false){
  463.                     // messaggio di errore
  464.                     boolean errore404 = false;
  465.                     if(op2Properties!=null && !op2Properties.isGenerazioneErroreHttpMethodUnsupportedProxyEnabled()){
  466.                         errore404 = true;
  467.                     }
  468.                     
  469.                     if(errore404){
  470.                         res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeHttpMethodNotSupported(IDService.PROXY, method)));
  471.                         return;
  472.                     }
  473.                     else{
  474.                         
  475.                         res.setStatus(500);
  476.                         
  477.                         ConnectorUtils.generateErrorMessage(IDService.PROXY,method,req,res, ConnectorUtils.getMessageHttpMethodNotSupported(method), false, true);
  478.                                 
  479.                         try{
  480.                             res.getOutputStream().flush();
  481.                         }catch(Exception eClose){
  482.                             // ignore
  483.                         }
  484.                         try{
  485.                             res.getOutputStream().close();
  486.                         }catch(Exception eClose){
  487.                             // ignore
  488.                         }
  489.                         
  490.                         return;
  491.                     }
  492.                 }
  493.                 
  494.                 // Dispatching al servizio 
  495.                 Proxy proxy = new Proxy();
  496.                 req.setAttribute(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME.getValue(), protocolContext.getProtocolName());
  497.                 proxy.doGet(req, res);
  498.                 
  499.             }
  500.             else{
  501.                 throw new Exception("Service ["+function+"] not supported");
  502.             }
  503.             
  504.         } catch (Exception e) {
  505.             
  506.             StringBuilder bf = new StringBuilder();
  507.             bf.append("RemoteAddr["+req.getRemoteAddr()+"] ");
  508.             bf.append("RemoteHost["+req.getRemoteHost()+"] ");
  509.             bf.append("RemotePort["+req.getRemotePort()+"] ");
  510.             bf.append("RemoteUser["+req.getRemoteUser()+"] ");
  511.             bf.append("LocalAddr["+req.getLocalAddr()+"] ");
  512.             bf.append("LocalHost["+req.getLocalName()+"] ");
  513.             bf.append("LocalPort["+req.getLocalPort()+"] ");
  514.             bf.append("ServerName["+req.getServerName()+"] ");
  515.             bf.append("ServerPort["+req.getServerPort()+"] ");
  516.                         
  517.             if(logCore!=null){
  518.                 logCore.error(e.getMessage(),e);
  519.                 logCore.error("Detail: "+bf.toString());
  520.             }
  521.             else{
  522.                 logOpenSPCoop2Servlet.error(e.getMessage(),e);
  523.                 logOpenSPCoop2Servlet.error("Detail: "+bf.toString());
  524.             }
  525.             
  526.             // log su file core
  527.             StringBuilder bfLogError = new StringBuilder();
  528.             try {
  529.                 ConnectorUtils.generateErrorMessage(IDService.OPENSPCOOP2_SERVLET,method,req,bfLogError, e.getMessage(), true, false);
  530.                 if(logCore!=null){
  531.                     logCore.error(bfLogError.toString());
  532.                 }
  533.                 else{
  534.                     logOpenSPCoop2Servlet.error(bfLogError.toString());
  535.                 }
  536.             }catch(Throwable t) {
  537.                 if(logCore!=null){
  538.                     logCore.error("generateErrorMessage log failed: "+t.getMessage(),t);
  539.                 }
  540.                 else{
  541.                     logOpenSPCoop2Servlet.error("generateErrorMessage log failed: "+t.getMessage(),t);
  542.                 }
  543.             }
  544.             
  545.             // messaggio di errore
  546.             boolean errore404 = true;
  547.             if(op2Properties!=null && op2Properties.isGenerazioneErroreProtocolloNonSupportato()){
  548.                 errore404 = false;
  549.             }
  550.             
  551.             if(errore404){
  552.                 try {
  553.                     res.sendError(404,ConnectorUtils.generateError404Message(ConnectorUtils.getFullCodeProtocolUnsupported(IDService.OPENSPCOOP2_SERVLET)));
  554.                 }catch(Throwable t) {
  555.                     if(logCore!=null){
  556.                         logCore.error("sendError404 failed: "+t.getMessage(),t);
  557.                     }
  558.                     else{
  559.                         logOpenSPCoop2Servlet.error("sendError404 failed: "+t.getMessage(),t);
  560.                     }
  561.                 }
  562.             }
  563.             else{
  564.                 res.setStatus(500);

  566.                 try {
  567.                     ConnectorUtils.generateErrorMessage(IDService.OPENSPCOOP2_SERVLET,method,req,res, e.getMessage(), true, true);
  568.                 }catch(Throwable t) {
  569.                     if(logCore!=null){
  570.                         logCore.error("generateErrorMessage failed: "+t.getMessage(),t);
  571.                     }
  572.                     else{
  573.                         logOpenSPCoop2Servlet.error("generateErrorMessage failed: "+t.getMessage(),t);
  574.                     }
  575.                 }
  576.                 
  577.                 try{
  578.                     res.getOutputStream().flush();
  579.                 }catch(Throwable eClose){
  580.                     // ignore
  581.                 }
  582.                 try{
  583.                     res.getOutputStream().close();
  584.                 }catch(Throwable eClose){
  585.                     // ignore
  586.                 }
  587.                 
  588.             }
  589.             
  590.         }
  591.         

  593.         
  594.     }
  595.     

  597.     

  599. }
Created with JaCoCo 0.8.8.202204050719