ConnettoreStatus.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.core.connettori;

  23. import java.io.ByteArrayInputStream;
  24. import java.sql.Connection;
  25. import java.util.ArrayList;
  26. import java.util.Date;
  27. import java.util.HashMap;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;

  32. import org.apache.commons.lang.StringUtils;
  33. import org.openspcoop2.core.config.Connettore;
  34. import org.openspcoop2.core.config.PortaApplicativa;
  35. import org.openspcoop2.core.config.PortaApplicativaServizioApplicativo;
  36. import org.openspcoop2.core.config.PortaDelegata;
  37. import org.openspcoop2.core.config.PortaDelegataAzione;
  38. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  39. import org.openspcoop2.core.config.ServizioApplicativo;
  40. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  41. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  42. import org.openspcoop2.core.constants.CostantiConnettori;
  43. import org.openspcoop2.core.constants.CostantiLabel;
  44. import org.openspcoop2.core.constants.TipiConnettore;
  45. import org.openspcoop2.core.constants.TipoPdD;
  46. import org.openspcoop2.core.controllo_traffico.beans.DatiTransazione;
  47. import org.openspcoop2.core.controllo_traffico.beans.RisultatoStatistico;
  48. import org.openspcoop2.core.controllo_traffico.constants.TipoPeriodoStatistico;
  49. import org.openspcoop2.core.id.IDServizio;
  50. import org.openspcoop2.core.id.IDServizioApplicativo;
  51. import org.openspcoop2.core.id.IDSoggetto;
  52. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  53. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  54. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  55. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  56. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  57. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  58. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  59. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  60. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  61. import org.openspcoop2.message.constants.Costanti;
  62. import org.openspcoop2.message.constants.MessageRole;
  63. import org.openspcoop2.message.constants.MessageType;
  64. import org.openspcoop2.message.soap.TunnelSoapUtils;
  65. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  66. import org.openspcoop2.pdd.config.DBManager;
  67. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  68. import org.openspcoop2.pdd.config.Resource;
  69. import org.openspcoop2.pdd.core.Utilities;
  70. import org.openspcoop2.pdd.core.controllo_traffico.policy.GestoreCacheControlloTraffico;
  71. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  72. import org.openspcoop2.protocol.engine.builder.Sbustamento;
  73. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  74. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  75. import org.openspcoop2.protocol.engine.validator.Validatore;
  76. import org.openspcoop2.protocol.engine.validator.ValidazioneSintattica;
  77. import org.openspcoop2.protocol.sdk.Busta;
  78. import org.openspcoop2.protocol.sdk.BustaRawContent;
  79. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  80. import org.openspcoop2.protocol.sdk.Integrazione;
  81. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  82. import org.openspcoop2.protocol.sdk.Riscontro;
  83. import org.openspcoop2.protocol.sdk.Trasmissione;
  84. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  85. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  86. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  87. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  88. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  89. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  90. import org.openspcoop2.protocol.sdk.validator.IValidatoreErrori;
  91. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  92. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  93. import org.openspcoop2.utils.UtilsException;
  94. import org.openspcoop2.utils.date.DateManager;
  95. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  96. import org.openspcoop2.utils.rest.problem.JsonSerializer;
  97. import org.openspcoop2.utils.rest.problem.ProblemRFC7807;
  98. import org.openspcoop2.utils.rest.problem.XmlSerializer;
  99. import org.openspcoop2.utils.transport.TransportResponseContext;
  100. import org.openspcoop2.utils.transport.TransportUtils;
  101. import org.openspcoop2.utils.transport.http.HttpConstants;
  102. import org.openspcoop2.utils.transport.http.HttpUtilities;


  105. /**
  106.  * Classe utilizzata per ottenere lo status di una determinata
  107.  * erogazione/fruizione
  108.  *
  109.  *
  110.  * @author Tommaso Burlon (tommaso.burlon@link.it)
  111.  * @author $Author$
  112.  * @version $Rev$, $Date$
  113.  */

  115. public class ConnettoreStatus extends ConnettoreBaseWithResponse {
  116.     
  117.     @Override
  118.     public String getProtocollo() {
  119.         return "";
  120.     }
  121.     
  122.     public static final String LOCATION = "govway://status";
  123.     
  124.     private DumpByteArrayOutputStream requestBout = null;

  126.     public static String getMessage(ConnettoreStatusResponseType statusResponseType, MessageType messageTypeRequest) throws UtilsException {
  127.         
  128.         ProblemRFC7807 problemRFC7807 = new ProblemRFC7807();
  129.         problemRFC7807.setStatus(200);
  130.         problemRFC7807.setDetail("Il servizio funziona correttamente");
  131.         problemRFC7807.setTitle("Success");
  132.         problemRFC7807.setType("https://httpstatuses.com/200");
  133.         
  134.         switch(statusResponseType) {
  135.         case MODI:{
  136.             return getMessageModI(messageTypeRequest, problemRFC7807);
  137.         }
  138.         case VUOTO: return "";
  139.         case XML: {
  140.             XmlSerializer xmlSerializer = new XmlSerializer();  
  141.             return xmlSerializer.toString(problemRFC7807).replace("problem", "status");
  142.         }
  143.         case JSON: {
  144.             JsonSerializer jsonSerializer = new JsonSerializer();
  145.             return jsonSerializer.toString(problemRFC7807);
  146.         }
  147.         case TEXT: return "Il servizio funziona correttamente";
  148.         default: return null;
  149.         }
  150.     }
  151.     private static String getMessageModI(MessageType messageTypeRequest, ProblemRFC7807 problemRFC7807) throws UtilsException {
  152.         switch (messageTypeRequest) {
  153.             case SOAP_11:
  154.             case SOAP_12:
  155.             {
  156.                 XmlSerializer xmlSerializer = new XmlSerializer();  
  157.                 String p = xmlSerializer.toString(problemRFC7807, true);
  158.                 return "<?xml version='1.0' encoding='UTF-8'?>"
  159.                     + "<soapenv:Envelope xmlns:soapenv=\""+(MessageType.SOAP_11.equals(messageTypeRequest) ? Costanti.SOAP_ENVELOPE_NAMESPACE : Costanti.SOAP12_ENVELOPE_NAMESPACE)+"\">"
  160.                     + "<soapenv:Body>"
  161.                     + p
  162.                     + "</soapenv:Body>"
  163.                     + "</soapenv:Envelope>";
  164.             }
  165.             case XML:{
  166.                 XmlSerializer xmlSerializer = new XmlSerializer();  
  167.                 return xmlSerializer.toString(problemRFC7807);
  168.             }
  169.             case JSON:
  170.             case BINARY:
  171.             case MIME_MULTIPART:{
  172.                 // in futuro valutare se usare l'accept
  173.                 JsonSerializer jsonSerializer = new JsonSerializer();
  174.                 return jsonSerializer.toString(problemRFC7807);
  175.             }
  176.         }
  177.         throw new UtilsException("Message type unknown");
  178.     }
  179.     
  180.     public static String getContentType(ConnettoreStatusResponseType statusResponseType, MessageType messageTypeRequest) throws UtilsException {
  181.         switch(statusResponseType) {
  182.         case MODI: return getContentTypeModI(messageTypeRequest);
  183.         case VUOTO: return null;
  184.         case XML: return HttpConstants.CONTENT_TYPE_XML;
  185.         case JSON: return HttpConstants.CONTENT_TYPE_JSON;
  186.         case TEXT: return HttpConstants.CONTENT_TYPE_PLAIN;
  187.         default: return null;
  188.         }
  189.     }
  190.     private static String getContentTypeModI(MessageType messageTypeRequest) throws UtilsException {
  191.         switch (messageTypeRequest) {
  192.             case SOAP_11:{
  193.                 return HttpConstants.CONTENT_TYPE_SOAP_1_1;
  194.             }
  195.             case SOAP_12:
  196.             {
  197.                 return HttpConstants.CONTENT_TYPE_SOAP_1_2;
  198.             }
  199.             case XML:{
  200.                 return HttpConstants.CONTENT_TYPE_XML;
  201.             }
  202.             case JSON:
  203.             case BINARY:
  204.             case MIME_MULTIPART:{
  205.                 return HttpConstants.CONTENT_TYPE_JSON;
  206.             }
  207.         }
  208.         throw new UtilsException("Message type unknown");
  209.     }
  210.     
  211.     private void testConnectivityErogazione(Map<Long, String> connettoriServizio, Map<Long, String> connettoriServizioNomeConnettoreMultiplo) throws DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  212.         ConfigurazionePdDManager configurazioneManager = ConfigurazionePdDManager.getInstance();
  213.         IDServizio idServizio = this.getServizio();
  214.         List<MappingErogazionePortaApplicativa> mappings = configurazioneManager.getMappingErogazionePortaApplicativaList(idServizio, this.requestInfo);
  215.         for (MappingErogazionePortaApplicativa mapping : mappings) {
  216.             PortaApplicativa pa = configurazioneManager.getPortaApplicativaSafeMethod(mapping.getIdPortaApplicativa(), this.requestInfo);
  217.             if (pa.equals(this.pa)) 
  218.                 continue;
  219.             List<PortaApplicativaServizioApplicativo> serviziApplicativi = pa.getServizioApplicativo();
  220.             
  221.             for (PortaApplicativaServizioApplicativo sa : serviziApplicativi) {                     
  222.                 IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  223.                 idServizioApplicativo.setNome(sa.getNome());
  224.                 idServizioApplicativo.setIdSoggettoProprietario(new IDSoggetto(pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario()));
  225.                 ServizioApplicativo servizioApplicativo = configurazioneManager.getServizioApplicativo(idServizioApplicativo, this.requestInfo);
  226.                 
  227.                 testConnectivityErogazione(connettoriServizio, connettoriServizioNomeConnettoreMultiplo, 
  228.                         mapping,
  229.                         sa, servizioApplicativo);
  230.             }
  231.         }
  232.     }
  233.     private void testConnectivityErogazione(Map<Long, String> connettoriServizio, Map<Long, String> connettoriServizioNomeConnettoreMultiplo, 
  234.             MappingErogazionePortaApplicativa mapping,
  235.             PortaApplicativaServizioApplicativo sa, ServizioApplicativo servizioApplicativo) {      
  236.         if (servizioApplicativo.getInvocazioneServizio() != null && 
  237.                 servizioApplicativo.getInvocazioneServizio().getConnettore() != null &&
  238.                 servizioApplicativo.getInvocazioneServizio().getConnettore().getId()!=null) {
  239.             testConnectivityErogazione(servizioApplicativo.getInvocazioneServizio().getConnettore(), mapping, connettoriServizio);
  240.             if(sa.getDatiConnettore()!=null && sa.getDatiConnettore().getNome()!=null && StringUtils.isNotEmpty(sa.getDatiConnettore().getNome())) {
  241.                 connettoriServizioNomeConnettoreMultiplo.put(servizioApplicativo.getInvocazioneServizio().getConnettore().getId(), sa.getDatiConnettore().getNome());
  242.             }
  243.         }
  244.         if (servizioApplicativo.getRispostaAsincrona() != null && 
  245.                 servizioApplicativo.getRispostaAsincrona().getConnettore() != null &&
  246.                 servizioApplicativo.getRispostaAsincrona().getConnettore().getId()!=null) {
  247.             testConnectivityErogazione(servizioApplicativo.getRispostaAsincrona().getConnettore(), mapping, connettoriServizio);
  248.             connettoriServizioNomeConnettoreMultiplo.put(servizioApplicativo.getRispostaAsincrona().getConnettore().getId(), "Risposta asincrona");
  249.         }
  250.     }
  251.     private void testConnectivityErogazione(Connettore connettore, MappingErogazionePortaApplicativa mapping, Map<Long, String> connettoriServizio) {
  252.         if (connettore != null && connettore.getId() != null && checkConnectivitySupported(connettore.getTipo())) {
  253.             String labelGruppo = mapping.getDescrizione();
  254.             if(mapping.isDefault() &&
  255.                 (labelGruppo==null || StringUtils.isEmpty(labelGruppo))) {
  256.                 labelGruppo = org.openspcoop2.core.constants.Costanti.MAPPING_DESCRIZIONE_DEFAULT;
  257.             }
  258.             connettoriServizio.put(connettore.getId(), labelGruppo);
  259.         }
  260.     }
  261.     
  262.     private void testConnectivityFruizione(Map<Long, String> connettoriServizio) throws DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound {
  263.         ConfigurazionePdDManager configurazioneManager = ConfigurazionePdDManager.getInstance();
  264.         IDServizio idServizio = this.getServizio();
  265.         IDSoggetto idFruitore = new IDSoggetto(this.pd.getTipoSoggettoProprietario(), this.pd.getNomeSoggettoProprietario());
  266.         
  267.         List<MappingFruizionePortaDelegata> mappings = configurazioneManager.getMappingFruizionePortaDelegataList(idFruitore, idServizio, this.requestInfo);
  268.         for (MappingFruizionePortaDelegata mapping : mappings) {
  269.             PortaDelegata pd = configurazioneManager.getPortaDelegataSafeMethod(mapping.getIdPortaDelegata(), null);
  270.             if (pd.equals(this.pd)) 
  271.                 continue;                   
  272.             PortaDelegataAzione azioni = pd.getAzione();
  273.             for (String azione : azioni.getAzioneDelegataList()) {
  274.                 if (idServizio != null)
  275.                     idServizio.setAzione(azione);
  276.                 Connettore connettore = configurazioneManager.getForwardRoute(idFruitore, idServizio, false, null);
  277.                 testConnectivityFruizione(connettore, mapping, connettoriServizio);
  278.             }
  279.         }
  280.     }
  281.     private void testConnectivityFruizione(Connettore connettore, MappingFruizionePortaDelegata mapping, Map<Long, String> connettoriServizio) {
  282.         if (connettore != null && connettore.getId() != null && checkConnectivitySupported(connettore.getTipo())) {
  283.             String labelGruppo = mapping.getDescrizione();
  284.             if(mapping.isDefault() &&
  285.                 (labelGruppo==null || StringUtils.isEmpty(labelGruppo))) {
  286.                 labelGruppo = org.openspcoop2.core.constants.Costanti.MAPPING_DESCRIZIONE_DEFAULT;
  287.             }
  288.             connettoriServizio.put(connettore.getId(), labelGruppo);
  289.         }
  290.     }
  291.     
  292.     private boolean checkConnectivitySupported(String tipoConnettore) {
  293.         TipiConnettore tipo = TipiConnettore.toEnumFromName(tipoConnettore);
  294.         return tipo!=null && (TipiConnettore.HTTP.equals(tipo) || TipiConnettore.HTTPS.equals(tipo)); 
  295.     }
  296.     
  297.     private void testConnectivity() throws DriverRegistroServiziException, DriverConfigurazioneException, DriverConfigurazioneNotFound, ConnettoreException {
  298.         Map<Long, String> connettoriServizio = new HashMap<>();
  299.         Map<Long, String> connettoriServizioNomeConnettoreMultiplo = new HashMap<>();
  300.         
  301.         if (this.pd != null)
  302.             this.testConnectivityFruizione(connettoriServizio);
  303.         
  304.         if (this.pa != null)
  305.             this.testConnectivityErogazione(connettoriServizio, connettoriServizioNomeConnettoreMultiplo);
  306.         
  307.         if (this.debug)
  308.             this.logger.debug("Inizio test connettivita sul servizio: " + this.getServizio() + ", id connettori: {" + connettoriServizio.keySet() + "}");
  309.         
  310.         for (Map.Entry<Long, String> entry : connettoriServizio.entrySet()) {
  311.             try {
  312.                 ConnettoreCheck.check(entry.getKey(), this.pd != null, null);
  313.             } catch(ConnettoreException e) {
  314.                 String nomeConnettore = connettoriServizioNomeConnettoreMultiplo.get(entry.getKey());
  315.                 if(nomeConnettore==null || StringUtils.isEmpty(nomeConnettore)) {
  316.                     nomeConnettore="";
  317.                 }
  318.                 else {
  319.                     nomeConnettore = " '"+nomeConnettore+"'";
  320.                 }
  321.                 throw new ConnettoreException("connettività fallita verso il connettore"+nomeConnettore+" del gruppo '" + entry.getValue() + "': " + e.getMessage());
  322.             }
  323.         }
  324.     }
  325.     
  326.     private IDServizio getServizio() throws DriverRegistroServiziException {
  327.         if (this.pd != null) {
  328.             return IDServizioFactory.getInstance().getIDServizioFromValues(
  329.                     this.pd.getServizio().getTipo(), 
  330.                     this.pd.getServizio().getNome(), 
  331.                     this.getSoggettoErogatore(),
  332.                     this.pd.getServizio().getVersione());
  333.         }
  334.         
  335.         if (this.pa != null) {
  336.             return IDServizioFactory.getInstance().getIDServizioFromValues(
  337.                     this.pa.getServizio().getTipo(), 
  338.                     this.pa.getServizio().getNome(), 
  339.                     this.getSoggettoErogatore(),
  340.                     this.pa.getServizio().getVersione());
  341.         }
  342.         
  343.         return null;
  344.     }
  345.     
  346.     private IDSoggetto getSoggettoFruitore() {
  347.         return this.pd == null ? null : new IDSoggetto(this.pd.getTipoSoggettoProprietario(), this.pd.getNomeSoggettoProprietario());
  348.     }
  349.     
  350.     private IDSoggetto getSoggettoErogatore() {
  351.         if (this.pd != null)
  352.             return new IDSoggetto(this.pd.getSoggettoErogatore().getTipo(), this.pd.getSoggettoErogatore().getNome());
  353.         if (this.pa != null)
  354.             return new IDSoggetto(this.pa.getTipoSoggettoProprietario(), this.pa.getNomeSoggettoProprietario());
  355.         return null;
  356.     }
  357.     
  358.     private List<String> getOperations() {
  359.         List<String> l = null;
  360.         if (this.pd != null)
  361.             return this.pd.getAzione().getAzioneDelegata();
  362.         if (this.pa != null)
  363.             return this.pa.getAzione().getAzioneDelegata();
  364.         return l;
  365.     }
  366.     
  367.     private void testStatistics() throws Exception {
  368.         DatiTransazione datiTransazioni = new DatiTransazione();
  369.         datiTransazioni.setDominio(this.getSoggettoErogatore());
  370.         datiTransazioni.setIdTransazione(this.idTransazione);
  371.         datiTransazioni.setModulo(this.idModulo);
  372.         
  373.         String periodRaw = this.getDynamicProperty(this.tipoConnettore, false, CostantiConnettori.CONNETTORE_STATUS_PERIOD, this.dynamicMap);
  374.         String periodValueRaw = this.getDynamicProperty(this.tipoConnettore, false, CostantiConnettori.CONNETTORE_STATUS_PERIOD_VALUE, this.dynamicMap);
  375.         String lifetimeRaw = this.getDynamicProperty(this.tipoConnettore, false, CostantiConnettori.CONNETTORE_STATUS_STAT_LIFETIME, this.dynamicMap);
  376.         
  377.         if (periodRaw == null)
  378.             throw new ConnettoreException("il tipo del periodo statistico non corretto, valori possibili: " + TipoPeriodoStatistico.toArray());
  379.         
  380.         TipoPeriodoStatistico period = TipoPeriodoStatistico.valueOf(periodRaw.toUpperCase());
  381.         Integer periodValue = Integer.valueOf(periodValueRaw);
  382.         Integer lifeTime = lifetimeRaw != null ? Integer.valueOf(lifetimeRaw) : Integer.MAX_VALUE;
  383.         
  384.         
  385.         if (periodValue <= 0)
  386.             throw new ConnettoreException("il valore del periodo deve essere un valore > 1");
  387.         
  388.         if (this.debug)
  389.             this.logger.debug("Inizio analisi statistica sulle transazioni del servizio:" + this.getServizio());
  390.         
  391.         Date now = new Date();
  392.         RisultatoStatistico numOk = GestoreCacheControlloTraffico.getInstance().readNumeroEsiti(period, periodValue, now, List.of(0), this.getServizio(), this.getSoggettoFruitore(), this.getOperations(), datiTransazioni, this.state, lifeTime);
  393.         RisultatoStatistico numTot = GestoreCacheControlloTraffico.getInstance().readNumeroEsiti(period, periodValue, now, null, this.getServizio(), this.getSoggettoFruitore(), this.getOperations(), datiTransazioni, this.state, lifeTime);
  394.         if (numOk.getRisultato() == 0 && numTot.getRisultato() > 0)
  395.             throw new ConnettoreException("trovate: " + numTot.getRisultato() + " transazioni con errore, nessuna transazione ok");
  396.     
  397.     }
  398.     
  399.     /* ********  METODI  ******** */

  401.     @Override
  402.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  403.         return this.initialize(request, false, responseCachingConfig);
  404.     }
  405.     
  406.     
  407.     @Override
  408.     protected boolean send(ConnettoreMsg request) {

  410.         boolean generaTrasmissione = false;
  411.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE)!=null){
  412.             generaTrasmissione = "true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE).trim());
  413.         }
  414.         
  415.         boolean generaTrasmissioneInvertita = false;
  416.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_INVERTITA)!=null){
  417.             generaTrasmissioneInvertita = "true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_INVERTITA).trim());
  418.         }
  419.         
  420.         boolean generaTrasmissioneAndataRitorno = false;
  421.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_ANDATA_RITORNO)!=null){
  422.             generaTrasmissioneAndataRitorno = "true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_ANDATA_RITORNO).trim());
  423.         }
  424.         
  425.         ConnettoreStatusResponseType statusResponseType = null;
  426.         boolean isStatisticalAnalysis = false;
  427.         boolean isTestConnectivity = false;
  428.         try {
  429.             String statusResponseTypeRaw = this.getDynamicProperty(this.tipoConnettore, true, CostantiConnettori.CONNETTORE_STATUS_RESPONSE_TYPE, this.dynamicMap);
  430.             String statisticalAnalysisRaw = this.getDynamicProperty(this.tipoConnettore, false, CostantiConnettori.CONNETTORE_STATUS_PERIOD, this.dynamicMap);
  431.             String testConnectivityRaw = this.getDynamicProperty(this.tipoConnettore, false, CostantiConnettori.CONNETTORE_STATUS_TEST_CONNECTIVITY, this.dynamicMap);
  432.         
  433.             isStatisticalAnalysis = (statisticalAnalysisRaw != null);
  434.             isTestConnectivity = (testConnectivityRaw != null && testConnectivityRaw.equals(Boolean.TRUE.toString()));
  435.             statusResponseType = ConnettoreStatusResponseType.fromString(statusResponseTypeRaw);
  436.         } catch(ConnettoreException e) {
  437.             statusResponseType = null;
  438.             this.logger.error("Tipologia risposta del connettore status non impostata");
  439.         }
  440.         
  441.         if (this.debug)
  442.             this.logger.debug("connettoreStatus: [type: " + statusResponseType + ", test connectivity: " + isTestConnectivity + ", statistical analysis: " + isStatisticalAnalysis);
  443.         
  444.         this.codice = 200;
  445.         DBManager dbManager = DBManager.getInstance();
  446.         Resource resource = null;
  447.         
  448.         StatefulMessage state = new StatefulMessage(null, this.logger.getLogger());
  449.         
  450.         ValidazioneSintattica validatoreSintattico = null;
  451.         Validatore validatoreProtocollo = null;
  452.         @SuppressWarnings("unused")
  453.         BustaRawContent<?> headerProtocolloRisposta = null;
  454.         String protocol = null;
  455.         try{
  456.             IProtocolFactory<?> protocolFactory = this.getProtocolFactory();
  457.             IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  458.             protocol = protocolFactory.getProtocol();
  459.             
  460.             // Tipologia di servizio
  461.             MessageType requestMessageType = this.requestMsg.getMessageType();
  462.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  463.             if(this.debug)
  464.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  465.             if(this.isSoap){
  466.                 soapMessageRequest = this.requestMsg.castAsSoap();
  467.             }
  468.             
  469.             
  470.             // Collezione header di trasporto per dump
  471.             Map<String, List<String>> propertiesTrasportoDebug = null;
  472.             if(this.isDumpBinarioRichiesta()) {
  473.                 propertiesTrasportoDebug = new HashMap<>();
  474.             }
  475.             
  476.             
  477.             // Impostazione Content-Type
  478.             String contentTypeRichiesta = null;
  479.             if(this.debug)
  480.                 this.logger.debug("Impostazione content type...");
  481.             if(this.isSoap){
  482.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  483.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  484.                 }else{
  485.                     contentTypeRichiesta = this.requestMsg.getContentType();
  486.                 }
  487.                 if(contentTypeRichiesta==null){
  488.                     throw new ConnettoreException("Content-Type del messaggio da spedire non definito");
  489.                 }
  490.             }
  491.             else{
  492.                 contentTypeRichiesta = this.requestMsg.getContentType();
  493.                 // Content-Type non obbligatorio in REST
  494.             }
  495.             if(this.debug)
  496.                 this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  497.             if(contentTypeRichiesta!=null){
  498.                 setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, this.logger, propertiesTrasportoDebug);
  499.             }
  500.             
  501.             
  502.             
  503.             // Impostazione timeout
  504.             if(this.debug)
  505.                 this.logger.debug("Impostazione timeout...");
  506.             int readConnectionTimeout = -1;
  507.             boolean readConnectionTimeoutConfigurazioneGlobale = true;
  508.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  509.                 try{
  510.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  511.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  512.                 }catch(Exception e){
  513.                     this.logger.error("Parametro "+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+" errato",e);
  514.                 }
  515.             }
  516.             if(readConnectionTimeout==-1){
  517.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  518.             }
  519.             if(this.debug)
  520.                 this.logger.info("Impostazione read timeout ["+readConnectionTimeout+"]",false);
  521.             
  522.             
  523.             // Impostazione Proprieta del trasporto
  524.             if(this.debug)
  525.                 this.logger.debug("Impostazione header di trasporto...");
  526.             this.forwardHttpRequestHeader();
  527.             if(this.propertiesTrasporto != null){
  528.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  529.                 while (keys.hasNext()) {
  530.                     String key = keys.next();
  531.                     List<String> values = this.propertiesTrasporto.get(key);
  532.                     if(this.debug && values!=null && !values.isEmpty()) {
  533.                             for (String value : values) {
  534.                                 this.logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);
  535.                             }
  536.                         }
  537.                     setRequestHeader(key, values, this.logger, propertiesTrasportoDebug);
  538.                 }
  539.             }
  540.             
  541.             
  542.             
  543.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  544.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  545.             if(this.isSoap && !this.sbustamentoSoap){
  546.                 if(this.debug)
  547.                     this.logger.debug("Impostazione soap action...");
  548.                 boolean existsTransportProperties = false;
  549.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  550.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  551.                     existsTransportProperties = (this.soapAction!=null);
  552.                 }
  553.                 if(!existsTransportProperties) {
  554.                     this.soapAction = soapMessageRequest.getSoapAction();
  555.                 }
  556.                 if(this.soapAction==null){
  557.                     this.soapAction="\"OpenSPCoop\"";
  558.                 }
  559.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  560.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  561.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  562.                 }
  563.                 if(this.debug)
  564.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  565.             }
  566.             
  567.             
  568.             
  569.             // SIMULAZIONE WRITE_TO
  570.             boolean consumeRequestMessage = true;
  571.             if(this.debug)
  572.                 this.logger.debug("Serializzazione (consume-request-message:"+consumeRequestMessage+")...");
  573.             if(this.isDumpBinarioRichiesta()) {
  574.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  575.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  576.                 
  577.                 this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  578.                 
  579.                 if(this.isSoap && this.sbustamentoSoap){
  580.                     this.logger.debug("Sbustamento...");
  581.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  582.                 }else{
  583.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  584.                 }
  585.                 this.requestBout.flush();
  586.                 this.requestBout.close();
  587.                                     
  588.                 this.dataRichiestaInoltrata = DateManager.getDate();
  589.                 
  590.                 this.dumpBinarioRichiestaUscita(this.requestBout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  591.             }
  592.             else {
  593.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  594.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue()); 
  595.                 if(this.isSoap && this.sbustamentoSoap){
  596.                     this.logger.debug("Sbustamento...");
  597.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  598.                 }else{
  599.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  600.                 }
  601.                 this.requestBout.flush();
  602.                 this.requestBout.close();
  603.                 
  604.                 this.dataRichiestaInoltrata = DateManager.getDate();
  605.             }
  606.             
  607.             
  608.             
  609.             
  610.             
  611.             
  612.             /* ------------  PostOutRequestHandler ------------- */
  613.             this.postOutRequest();
  614.             
  615.             
  616.             
  617.             /* ------------  PreInResponseHandler ------------- */
  618.             this.preInResponse();
  619.             
  620.             // Lettura risposta parametri NotifierInputStream per la risposta
  621.             org.openspcoop2.utils.io.notifier.NotifierInputStreamParams notifierInputStreamParams = null;
  622.             if(this.preInResponseContext!=null){
  623.                 notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  624.             }
  625.             
  626.             // verifica connettivita
  627.             if (isTestConnectivity) {
  628.                 this.testConnectivity();
  629.             }
  630.             
  631.             // analisi statistica
  632.             if (isStatisticalAnalysis) {
  633.                 this.testStatistics();
  634.             }
  635.             
  636.             this.isResponse = new ByteArrayInputStream(ConnettoreStatus.getMessage(statusResponseType, this.requestMsg.getMessageType()).getBytes());
  637.             this.tipoRisposta = ConnettoreStatus.getContentType(statusResponseType, this.requestMsg.getMessageType());
  638.             
  639.             this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  640.             
  641.             this.initCheckContentTypeConfiguration();
  642.             
  643.             this.messageTypeResponse = this.requestMsg.getMessageType();
  644.             
  645.             if(this.isDumpBinarioRisposta()){
  646.                 this.dumpResponse(this.propertiesTrasportoRisposta);
  647.             }
  648.             
  649.             if(this.isResponse!=null) {
  650.                 this.emitDiagnosticResponseRead(this.isResponse);
  651.             }
  652.             
  653.             OpenSPCoop2MessageFactory messageFactory = Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo, MessageRole.RESPONSE);
  654.             OpenSPCoop2MessageParseResult pr;
  655.             
  656.             if (this.isResponse != null) {
  657.                 pr = messageFactory.createMessage(this.messageTypeResponse, MessageRole.RESPONSE,
  658.                         this.tipoRisposta,
  659.                         this.isResponse,notifierInputStreamParams,
  660.                         this.openspcoopProperties.getAttachmentsProcessingMode());
  661.             } else {
  662.                 TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  663.                 responseContext.setCodiceTrasporto(this.codice+"");
  664.                 responseContext.setContentLength(0);
  665.                 
  666.                 pr = messageFactory.createMessage(this.messageTypeResponse,responseContext,
  667.                         this.isResponse,notifierInputStreamParams,
  668.                         this.openspcoopProperties.getAttachmentsProcessingMode());
  669.             }
  670.             if(pr.getParseException()!=null){
  671.                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  672.             }
  673.             this.responseMsg = pr.getMessage_throwParseException();
  674.             
  675.             validatoreSintattico = new ValidazioneSintattica(this.getPddContext(),state,this.responseMsg, this.openspcoopProperties.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD), protocolFactory); 

  677.             if(validatoreSintattico.verifyProtocolPresence(TipoPdD.APPLICATIVA,null,RuoloMessaggio.RISPOSTA) && 
  678.                     !CostantiLabel.SDI_PROTOCOL_NAME.equals(protocolFactory.getProtocol())){ // evitare sdi per far funzionare il protocollo sdi con la sonda.
  679.                 
  680.                 // getBusta
  681.                 ProprietaValidazione property = new ProprietaValidazione();
  682.                 property.setValidazioneConSchema(false);
  683.                 property.setValidazioneProfiloCollaborazione(false);
  684.                 property.setValidazioneManifestAttachments(false);
  685.                 
  686.                 validatoreProtocollo = new Validatore(this.responseMsg,this.getPddContext(),property,null,
  687.                         this.openspcoopProperties.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD), protocolFactory);
  688.                 
  689.                 if(!validatoreProtocollo.validazioneSintattica()){
  690.                     throw new ConnettoreException("Busta non presente: "+validatoreProtocollo.getErrore().getDescrizione(protocolFactory));
  691.                 }
  692.                 
  693.                 // Leggo busta di richiesta
  694.                 Busta busta = validatoreProtocollo.getBusta();
  695.                 
  696.                 // informazione spcoopErrore
  697.                 IValidatoreErrori validatoreErrori = protocolFactory.createValidatoreErrori(state);
  698.                 ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  699.                 pValidazioneErrori.setIgnoraEccezioniNonGravi(protocolManager.isIgnoraEccezioniNonGravi());
  700.                 boolean isBustaSPCoopErrore = validatoreErrori.isBustaErrore(busta,this.responseMsg,pValidazioneErrori);
  701.                 
  702.                 // Gestisco il manifest se il messaggio lo possiede
  703.                 boolean gestioneManifest = false;
  704.                 // La gestione manifest non la devo fare a questo livello.
  705.                 // Se mi arriva un messaggio senza manifest, vuol dire che era disabilitata e quindi anche nella risposta non ci deve essere
  706.                 // In egual misura se arriva un messaggio con manifest, significa che ci deve essere anche nella risposta
  707.                 // Poiche' la risposta e' esattamente uguale (nel body e negli allegati) alla richiesta, 
  708.                 // venendo costruita dai bytes della richiesta 
  709.                 
  710.                 // rimozione vecchia busta
  711.                 Sbustamento sbustatore = new Sbustamento(protocolFactory,state);
  712.                 ProtocolMessage protocolMessage = sbustatore.sbustamento(this.responseMsg,this.getPddContext(),
  713.                         busta,RuoloMessaggio.RICHIESTA, gestioneManifest, 
  714.                         this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  715.                         FaseSbustamento.PRE_CONSEGNA_RICHIESTA,this.requestInfo);
  716.                 if(protocolMessage!=null) {
  717.                     headerProtocolloRisposta = protocolMessage.getBustaRawContent();
  718.                     this.responseMsg = protocolMessage.getMessage(); // updated
  719.                 }
  720.                 
  721.                 // Creo busta di risposta solo se la busta di richiesta non conteneva una busta Errore
  722.                 if(!isBustaSPCoopErrore){
  723.             
  724.                     TipoOraRegistrazione tipoOraRegistrazione = this.openspcoopProperties.getTipoTempoBusta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  725.                     Busta bustaRisposta = busta.invertiBusta(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  726.                 
  727.                     bustaRisposta.setProfiloDiCollaborazione(busta.getProfiloDiCollaborazione());
  728.                     bustaRisposta.setServizio(busta.getServizio());
  729.                     bustaRisposta.setVersioneServizio(busta.getVersioneServizio());
  730.                     bustaRisposta.setTipoServizio(busta.getTipoServizio());
  731.                     bustaRisposta.setAzione(busta.getAzione());
  732.                     
  733.                     bustaRisposta.setInoltro(busta.getInoltro(),busta.getInoltroValue());
  734.                     bustaRisposta.setConfermaRicezione(busta.isConfermaRicezione());
  735.                     
  736.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(busta.getProfiloDiCollaborazione()) &&
  737.                             busta.isConfermaRicezione() &&
  738.                             this.openspcoopProperties.isGestioneRiscontri(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD)){
  739.                         // Attendono riscontro
  740.                         Riscontro r = new Riscontro();
  741.                         r.setID(busta.getID());
  742.                         r.setOraRegistrazione(DateManager.getDate());
  743.                         r.setTipoOraRegistrazione(TipoOraRegistrazione.SINCRONIZZATO);
  744.                         bustaRisposta.addRiscontro(r);
  745.                         
  746.                     } else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  747.                             busta.getRiferimentoMessaggio()==null){
  748.                         // devo generare ricevuta
  749.                         bustaRisposta.setTipoServizioCorrelato("SPC");
  750.                         bustaRisposta.setServizioCorrelato(busta.getServizio()+"Correlato");
  751.                     } else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  752.                             busta.getRiferimentoMessaggio()==null){
  753.                     
  754.                         // salvo messaggio sul database asincrono/repositoryBuste
  755.                     
  756.                         // get database
  757.                         try{
  758.                             resource = dbManager.getResource(this.openspcoopProperties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo),"ConnettoreStatus",busta.getID());
  759.                         }catch(Exception e){
  760.                             throw new ConnettoreException("Risorsa non ottenibile",e);
  761.                         }
  762.                         if(resource==null)
  763.                             throw new ConnettoreException("Risorsa is null");
  764.                         if(resource.getResource() == null)
  765.                             throw new ConnettoreException("Connessione is null");
  766.                         Connection connectionDB = (Connection) resource.getResource();
  767.                         
  768.                         state.setConnectionDB(connectionDB);
  769.                         
  770.                         // repository
  771.                         RepositoryBuste repositoryBuste = new RepositoryBuste(state, true,protocolFactory);
  772.                         repositoryBuste.registraBustaIntoInBox(busta, new ArrayList<>() ,
  773.                                 OpenSPCoop2Properties.getInstance().getRepositoryIntervalloScadenzaMessaggi());
  774.                         Integrazione infoIntegrazione = new Integrazione();
  775.                         infoIntegrazione.setIdModuloInAttesa(null);
  776.                         repositoryBuste.aggiornaInfoIntegrazioneIntoInBox(busta.getID(),infoIntegrazione);
  777.                     
  778.                         // asincrono
  779.                         ProfiloDiCollaborazione profiloCollaborazione = new ProfiloDiCollaborazione(state,protocolFactory);
  780.                         profiloCollaborazione.asincronoSimmetrico_registraRichiestaRicevuta(busta.getID(),busta.getCollaborazione(),
  781.                                 busta.getTipoServizioCorrelato(),busta.getServizioCorrelato(),busta.getVersioneServizioCorrelato(),true,
  782.                                 this.openspcoopProperties.getRepositoryIntervalloScadenzaMessaggi());
  783.                     
  784.                         // commit
  785.                         try{
  786.                             connectionDB.setAutoCommit(false);
  787.                             state.executePreparedStatement(); 
  788.                 
  789.                             connectionDB.commit();
  790.                             connectionDB.setAutoCommit(true);
  791.                         }catch (Exception e) {  
  792.                             this.logger.error("Riscontrato errore durante la gestione transazione del DB per la richiesta: "+e.getMessage());
  793.                             // Rollback quanto effettuato (se l'errore e' avvenuto sul commit, o prima nell'execute delle PreparedStatement)
  794.                             try{
  795.                                 connectionDB.rollback();
  796.                             }catch(Exception er){
  797.                                 // ignore
  798.                             }
  799.                             state.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il save del Msg
  800.                         }finally {
  801.                             // Ripristino connessione
  802.                             try{
  803.                                 connectionDB.setAutoCommit(true);
  804.                             }catch(Exception er){
  805.                                 // ignore
  806.                             }
  807.                         }
  808.                     
  809.                     }
  810.                 
  811.                     // Riferimento Messaggio
  812.                     bustaRisposta.setRiferimentoMessaggio(busta.getID());
  813.                     
  814.                     // Identificativo Messaggio
  815.                     String dominio = null;
  816.                     if(request.getConnectorProperties()!=null)
  817.                         dominio = request.getConnectorProperties().get("identificativo-porta");
  818.                     if(dominio==null){
  819.                         dominio = protocolFactory.createTraduttore().getIdentificativoPortaDefault(new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario()));
  820.                     }
  821.                     String idBustaRisposta = null;
  822.                     Imbustamento imbustatore = new Imbustamento(this.logger.getLogger(), protocolFactory, state);
  823.                     try{
  824.                         idBustaRisposta = 
  825.                             imbustatore.buildID(new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario(), dominio), 
  826.                                     null, 
  827.                                     this.openspcoopProperties.getGestioneSerializableDBAttesaAttiva(),
  828.                                     this.openspcoopProperties.getGestioneSerializableDBCheckInterval(),
  829.                                     RuoloMessaggio.RISPOSTA);
  830.                     }catch(Exception e){
  831.                         // rilancio
  832.                         throw new ConnettoreException(e);
  833.                     }
  834.                     bustaRisposta.setID(idBustaRisposta);
  835.                     
  836.                     if(generaTrasmissioneAndataRitorno){
  837.                         Trasmissione t = new Trasmissione();
  838.                         t.setTipoOrigine(busta.getTipoMittente());
  839.                         t.setOrigine(busta.getMittente());
  840.                         t.setIdentificativoPortaOrigine(busta.getIdentificativoPortaMittente());
  841.                         t.setIndirizzoOrigine(busta.getIndirizzoMittente());
  842.                         
  843.                         t.setTipoDestinazione(busta.getTipoDestinatario());
  844.                         t.setDestinazione(busta.getDestinatario());
  845.                         t.setIdentificativoPortaDestinazione(busta.getIdentificativoPortaDestinatario());
  846.                         t.setIndirizzoDestinazione(busta.getIndirizzoDestinatario());
  847.                         
  848.                         t.setOraRegistrazione(busta.getOraRegistrazione());
  849.                         t.setTempo(busta.getTipoOraRegistrazione(), busta.getTipoOraRegistrazioneValue());
  850.                         bustaRisposta.addTrasmissione(t);
  851.                     }
  852.                     if(generaTrasmissione || generaTrasmissioneInvertita || generaTrasmissioneAndataRitorno){
  853.                         Trasmissione t = new Trasmissione();
  854.                         if(generaTrasmissione || generaTrasmissioneAndataRitorno){
  855.                             t.setTipoOrigine(bustaRisposta.getTipoMittente());
  856.                             t.setOrigine(bustaRisposta.getMittente());
  857.                             t.setIdentificativoPortaOrigine(bustaRisposta.getIdentificativoPortaMittente());
  858.                             t.setIndirizzoOrigine(bustaRisposta.getIndirizzoMittente());
  859.                             
  860.                             t.setTipoDestinazione(bustaRisposta.getTipoDestinatario());
  861.                             t.setDestinazione(bustaRisposta.getDestinatario());
  862.                             t.setIdentificativoPortaDestinazione(bustaRisposta.getIdentificativoPortaDestinatario());
  863.                             t.setIndirizzoDestinazione(bustaRisposta.getIndirizzoDestinatario());
  864.                         }
  865.                         if(generaTrasmissioneInvertita){
  866.                             // invertita
  867.                             t.setTipoOrigine(bustaRisposta.getTipoDestinatario());
  868.                             t.setOrigine(bustaRisposta.getDestinatario());
  869.                             t.setIdentificativoPortaOrigine(bustaRisposta.getIdentificativoPortaDestinatario());
  870.                             t.setIndirizzoOrigine(bustaRisposta.getIndirizzoDestinatario());
  871.                             
  872.                             t.setTipoDestinazione(bustaRisposta.getTipoMittente());
  873.                             t.setDestinazione(bustaRisposta.getMittente());
  874.                             t.setIdentificativoPortaDestinazione(bustaRisposta.getIdentificativoPortaMittente());
  875.                             t.setIndirizzoDestinazione(bustaRisposta.getIndirizzoMittente());
  876.                         }
  877.                         t.setOraRegistrazione(bustaRisposta.getOraRegistrazione());
  878.                         t.setTempo(bustaRisposta.getTipoOraRegistrazione(), bustaRisposta.getTipoOraRegistrazioneValue());
  879.                         bustaRisposta.addTrasmissione(t);
  880.                     }
  881.                                 
  882.                     // imbustamento nuova busta
  883.                     Integrazione integrazione = new Integrazione();
  884.                     integrazione.setStateless(true);
  885.                     
  886.                     ProtocolMessage protocolMessageRisposta = imbustatore.imbustamentoRisposta(this.responseMsg,this.getPddContext(),
  887.                             bustaRisposta,busta,integrazione,gestioneManifest,false,
  888.                             this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  889.                             FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  890.                     if(protocolMessageRisposta!=null && !protocolMessageRisposta.isPhaseUnsupported()) {
  891.                         this.responseMsg = protocolMessageRisposta.getMessage(); // updated
  892.                     }
  893.                     
  894.                     protocolMessageRisposta = imbustatore.imbustamentoRisposta(this.responseMsg,this.getPddContext(),
  895.                             bustaRisposta,busta,integrazione,gestioneManifest,false,
  896.                             this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  897.                             FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  898.                     if(protocolMessageRisposta!=null && !protocolMessageRisposta.isPhaseUnsupported()) {
  899.                         this.responseMsg = protocolMessageRisposta.getMessage(); // updated
  900.                     }

  902.                 }
  903.                 else{
  904.                     // rimuovo il FAULT.
  905.                     if(this.responseMsg instanceof OpenSPCoop2SoapMessage){
  906.                         OpenSPCoop2SoapMessage soapMessage = this.responseMsg.castAsSoap();
  907.                         if(soapMessage.hasSOAPFault()){
  908.                             soapMessage.getSOAPBody().removeChild(soapMessage.getSOAPBody().getFault());
  909.                         }
  910.                     }
  911.                 }
  912.             }
  913.             
  914.             // content length
  915.             if(this.responseMsg!=null){
  916.                 this.contentLength = this.responseMsg.getIncomingMessageContentLength();
  917.             }
  918.             
  919.         }catch(Exception e){
  920.             this.eccezioneProcessamento = e;
  921.             String msgErrore = this.readExceptionMessageFromException(e);
  922.             if(this.generateErrorWithConnectorPrefix) {
  923.                 this.errore = "rilevata anomalia; "+msgErrore;
  924.             }
  925.             else {
  926.                 this.errore = msgErrore;
  927.             }
  928.             this.logger.error("Rilevata anomalia: "+msgErrore,e);
  929.             return false;
  930.         }finally{
  931.                     
  932.             // *** GB ***
  933.             if(validatoreSintattico!=null){
  934.                 validatoreSintattico.setHeaderSOAP(null);
  935.             }
  936.             validatoreSintattico = null;
  937.             if(validatoreProtocollo!=null){
  938.                 if(validatoreProtocollo.getValidatoreSintattico()!=null){
  939.                     validatoreProtocollo.getValidatoreSintattico().setHeaderSOAP(null);
  940.                 }
  941.                 validatoreProtocollo.setValidatoreSintattico(null);
  942.             }
  943.             validatoreProtocollo = null;
  944.             headerProtocolloRisposta = null;
  945.             // *** GB ***
  946.             
  947.             // release database
  948.             dbManager.releaseResource(this.openspcoopProperties.getIdentitaPortaDefault(protocol, this.requestInfo),
  949.                     "ConnettoreStatus", resource);
  950.         }
  951.         
  952.         return true;
  953.     }
  954.     
  955.     private void setRequestHeader(String key, String value, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  956.         List<String> list = new ArrayList<>(); 
  957.         list.add(value);
  958.         this.setRequestHeader(key, list, logger, propertiesTrasportoDebug);
  959.     }
  960.     
  961.     private void setRequestHeader(String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  962.         
  963.         if(this.debug && values!=null && !values.isEmpty()) {
  964.             for (String value : values) {
  965.                 logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);     
  966.             }
  967.         }
  968.         setRequestHeader(key, values, propertiesTrasportoDebug);
  969.         
  970.     }
  971.     @Override
  972.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  973.         this.propertiesTrasportoRisposta.put(key, values);
  974.     }
  975.     
  976.     /**
  977.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  978.      * 
  979.      * @return location di inoltro del messaggio
  980.      */
  981.     @Override
  982.     public String getLocation() throws ConnettoreException {
  983.         return LOCATION;
  984.     }

  986.     @Override
  987.     public void disconnect() throws ConnettoreException {
  988.         try {
  989.             if(this.requestBout!=null) {
  990.                 this.requestBout.clearResources();
  991.             }
  992.         }catch(Exception e) {
  993.             this.logger.error("Release resources failed: "+e.getMessage(), e);
  994.         }
  995.     }
  996. }




Created with JaCoCo 0.8.8.202204050719