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




  24. package org.openspcoop2.pdd.core.connettori;

  26. import java.util.ArrayList;
  27. import java.util.HashMap;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  33. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  34. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  35. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  36. import org.openspcoop2.message.constants.Costanti;
  37. import org.openspcoop2.message.constants.MessageRole;
  38. import org.openspcoop2.message.constants.MessageType;
  39. import org.openspcoop2.message.soap.TunnelSoapUtils;
  40. import org.openspcoop2.pdd.core.Utilities;
  41. import org.openspcoop2.utils.date.DateManager;
  42. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  43. import org.openspcoop2.utils.transport.TransportUtils;
  44. import org.openspcoop2.utils.transport.http.HttpConstants;


  47. /**
  48.  * Classe utilizzata per effettuare consegne di messaggi Soap, attraverso
  49.  * l'invocazione di un server http. 
  50.  *
  51.  *
  52.  * @author Poli Andrea (apoli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */

  57. public class ConnettoreNULL extends ConnettoreBase {
  58.     
  59.     @Override
  60.     public String getProtocollo() {
  61.         return "";
  62.     }
  63.     
  64.     public static final String LOCATION = "govway://dev/null";
  65.     
  66.     


  69.     /* ********  METODI  ******** */

  71.     @Override
  72.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  73.         
  74.         if(this.initialize(request, false, responseCachingConfig)==false){
  75.             return false;
  76.         }
  77.         
  78.         return true;
  79.         
  80.     }
  81.     
  82.     @Override
  83.     protected boolean send(ConnettoreMsg request) {
  84.         
  85.         this.codice = 200;
  86.         
  87.         try{
  88.             
  89.             // Tipologia di servizio
  90.             MessageType requestMessageType = this.requestMsg.getMessageType();
  91.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  92.             if(this.debug)
  93.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  94.             if(this.isSoap){
  95.                 soapMessageRequest = this.requestMsg.castAsSoap();
  96.             }
  97.             
  98.             
  99.             // Collezione header di trasporto per dump
  100.             Map<String, List<String>> propertiesTrasportoDebug = null;
  101.             if(this.isDumpBinarioRichiesta()) {
  102.                 propertiesTrasportoDebug = new HashMap<>();
  103.             }
  104.             
  105.             
  106.             // Impostazione Content-Type
  107.             String contentTypeRichiesta = null;
  108.             if(this.debug)
  109.                 this.logger.debug("Impostazione content type...");
  110.             if(this.isSoap){
  111.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  112.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  113.                 }else{
  114.                     contentTypeRichiesta = this.requestMsg.getContentType();
  115.                 }
  116.                 if(contentTypeRichiesta==null){
  117.                     throw new Exception("Content-Type del messaggio da spedire non definito");
  118.                 }
  119.             }
  120.             else{
  121.                 contentTypeRichiesta = this.requestMsg.getContentType();
  122.                 // Content-Type non obbligatorio in REST
  123.             }
  124.             if(this.debug)
  125.                 this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  126.             if(contentTypeRichiesta!=null){
  127.                 setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, this.logger, propertiesTrasportoDebug);
  128.             }
  129.             
  130.                         
  131.             // Impostazione Proprieta del trasporto
  132.             if(this.debug)
  133.                 this.logger.debug("Impostazione header di trasporto...");
  134.             this.forwardHttpRequestHeader();
  135.             if(this.propertiesTrasporto != null){
  136.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  137.                 while (keys.hasNext()) {
  138.                     String key = (String) keys.next();
  139.                     List<String> values = this.propertiesTrasporto.get(key);
  140.                     if(this.debug) {
  141.                         if(values!=null && !values.isEmpty()) {
  142.                             for (String value : values) {
  143.                                 this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  144.                             }
  145.                         }
  146.                     }
  147.                     
  148.                     setRequestHeader(key, values, this.logger, propertiesTrasportoDebug);
  149.                 }
  150.             }
  151.             
  152.             
  153.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  154.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  155.             if(this.isSoap && this.sbustamentoSoap == false){
  156.                 if(this.debug)
  157.                     this.logger.debug("Impostazione soap action...");
  158.                 boolean existsTransportProperties = false;
  159.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  160.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  161.                     existsTransportProperties = (this.soapAction!=null);
  162.                 }
  163.                 if(!existsTransportProperties) {
  164.                     this.soapAction = soapMessageRequest.getSoapAction();
  165.                 }
  166.                 if(this.soapAction==null){
  167.                     this.soapAction="\"OpenSPCoop\"";
  168.                 }
  169.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  170.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  171.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  172.                 }
  173.                 if(this.debug)
  174.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  175.             }
  176.             
  177.             
  178.             
  179.             // SIMULAZIONE WRITE_TO
  180.             boolean consumeRequestMessage = true;
  181.             if(this.debug)
  182.                 this.logger.debug("Serializzazione (consume-request-message:"+consumeRequestMessage+")...");
  183.             if(this.isDumpBinarioRichiesta()) {
  184.                 DumpByteArrayOutputStream bout = null;
  185.                 boolean close = true;
  186.                 try {
  187.                     bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  188.                             TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  189.                     
  190.                     this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  191.                     
  192.                     if(this.isSoap && this.sbustamentoSoap){
  193.                         this.logger.debug("Sbustamento...");
  194.                         TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,bout);
  195.                     }else{
  196.                         this.requestMsg.writeTo(bout, consumeRequestMessage);
  197.                     }
  198.                     bout.flush();
  199.                     bout.close();
  200.                     close = false;
  201.                                 
  202.                     this.dataRichiestaInoltrata = DateManager.getDate();
  203.                     
  204.                     this.dumpBinarioRichiestaUscita(bout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  205.                 }finally {
  206.                     try {
  207.                         if(close && bout!=null) {
  208.                             bout.close();
  209.                         }
  210.                     }catch(Throwable t) {
  211.                         // ignore
  212.                     }
  213.                     try {
  214.                         if(bout!=null) {
  215.                             bout.clearResources();
  216.                         }
  217.                     }catch(Throwable t) {
  218.                         this.logger.error("Release resources failed: "+t.getMessage(),t);
  219.                     }
  220.                 }
  221.             }
  222.             else {
  223.                 org.apache.commons.io.output.NullOutputStream nullOutputStream = org.apache.commons.io.output.NullOutputStream.INSTANCE;
  224.                 if(this.isSoap && this.sbustamentoSoap){
  225.                     this.logger.debug("Sbustamento...");
  226.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,nullOutputStream);
  227.                 }else{
  228.                     this.requestMsg.writeTo(nullOutputStream, consumeRequestMessage);
  229.                 }
  230.                 nullOutputStream.flush();
  231.                 nullOutputStream.close();
  232.                 
  233.                 this.dataRichiestaInoltrata = DateManager.getDate();
  234.             }
  235.         
  236.         }catch(Exception e){
  237.             this.eccezioneProcessamento = e;
  238.             this.logger.error("Riscontrato errore durante la writeTo",e);
  239.             this.errore = "Riscontrato errore durante la writeTo: " +this.readExceptionMessageFromException(e);
  240.             return false;
  241.         }
  242.         
  243.         try{
  244.             
  245.             /* ------------  PostOutRequestHandler ------------- */
  246.             this.postOutRequest();
  247.             
  248.         }catch(Exception e){
  249.             this.eccezioneProcessamento = e;
  250.             this.logger.error("Riscontrato errore durante la gestione PostOutRequestHandler",e);
  251.             this.errore = "Riscontrato errore durante la gestione PostOutRequestHandler: " +this.readExceptionMessageFromException(e);
  252.             return false;
  253.         }
  254.             
  255. //      org.openspcoop2.utils.io.notifier.NotifierInputStreamParams notifierInputStreamParams = null;
  256. //      try{
  257. //          
  258. //          /* ------------  PreInResponseHandler ------------- */
  259. //          this.preInResponse();
  260. //          
  261. //          // Lettura risposta parametri NotifierInputStream per la risposta
  262. //          if(this.preInResponseContext!=null){
  263. //              notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  264. //          }
  265. //          
  266. //      }catch(Exception e){
  267. //          this.eccezioneProcessamento = e;
  268. //          ConnettoreNULL.log.error("Riscontrato errore durante la gestione PreInResponseHandler",e);
  269. //          this.errore = "Riscontrato errore durante la gestione PreInResponseHandler: " +e.getMessage();
  270. //          return false;
  271. //      }
  272.         
  273.         try{
  274.                     
  275.             OpenSPCoop2MessageFactory messageFactory = Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo, MessageRole.RESPONSE);
  276.             this.responseMsg = messageFactory.createEmptyMessage(this.requestMsg.getMessageType(),MessageRole.RESPONSE);
  277.             
  278.         }catch(Exception e){
  279.             this.eccezioneProcessamento = e;
  280.             this.logger.error("Riscontrato errore durante la generazione di un msg SoapVuoto",e);
  281.             this.errore = "Riscontrato errore durante la generazione di un msg SoapVuoto: " +this.readExceptionMessageFromException(e);
  282.             return false;
  283.         }
  284.         
  285.         return true;
  286.     }

  288.     
  289.     private void setRequestHeader(String key, String value, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  290.         List<String> list = new ArrayList<>(); 
  291.         list.add(value);
  292.         this.setRequestHeader(key, list, logger, propertiesTrasportoDebug);
  293.     }
  294.     private void setRequestHeader(String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  295.         
  296.         if(this.debug) {
  297.             if(values!=null && !values.isEmpty()) {
  298.                 for (String value : values) {
  299.                     this.logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);        
  300.                 }
  301.             }
  302.         }
  303.         setRequestHeader(key, values, propertiesTrasportoDebug);
  304.         
  305.     }
  306.     @Override
  307.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  308.         // nop
  309.     }
  310.     
  311.     /**
  312.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  313.      * 
  314.      * @return location di inoltro del messaggio
  315.      * @throws ConnettoreException 
  316.      */
  317.     @Override
  318.     public String getLocation() throws ConnettoreException{
  319.         // Il connettore NULL ho possiede possibilita' di consegnare su di una url
  320.         //return ConnettoreUtils.buildLocationWithURLBasedParameter(this.requestMsg, this.propertiesUrlBased, LOCATION);
  321.         return LOCATION;
  322.     }
  323.     
  324. }




Created with JaCoCo 0.8.8.202204050719