ConnettoreFILE.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.io.ByteArrayOutputStream;
  27. import java.io.File;
  28. import java.io.FileInputStream;
  29. import java.io.FileOutputStream;
  30. import java.io.OutputStream;
  31. import java.util.ArrayList;
  32. import java.util.Enumeration;
  33. import java.util.HashMap;
  34. import java.util.Iterator;
  35. import java.util.List;
  36. import java.util.Map;
  37. import java.util.Properties;
  38. import java.util.Scanner;

  40. import org.apache.commons.lang.StringUtils;
  41. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  42. import org.openspcoop2.core.constants.CostantiConnettori;
  43. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  44. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  45. import org.openspcoop2.message.constants.Costanti;
  46. import org.openspcoop2.message.constants.MessageType;
  47. import org.openspcoop2.message.soap.TunnelSoapUtils;
  48. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  49. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  50. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  51. import org.openspcoop2.utils.Utilities;
  52. import org.openspcoop2.utils.date.DateManager;
  53. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  54. import org.openspcoop2.utils.resources.FileSystemUtilities;
  55. import org.openspcoop2.utils.transport.TransportUtils;
  56. import org.openspcoop2.utils.transport.http.HttpConstants;
  57. import org.openspcoop2.utils.transport.http.HttpUtilities;



  61. /**
  62.  * Classe utilizzata per effettuare consegne di messaggi su file system
  63.  *
  64.  *
  65.  * @author Poli Andrea (apoli@link.it)
  66.  * @author $Author$
  67.  * @version $Rev$, $Date$
  68.  */

  70. public class ConnettoreFILE extends ConnettoreBaseWithResponse {

  72.     @Override
  73.     public String getProtocollo() {
  74.         return "FILE";
  75.     }
  76.     
  77.     /* ********  F I E L D S  P R I V A T I  ******** */

  79.     public ByteArrayOutputStream outByte = new ByteArrayOutputStream();

  81.     /** File */
  82.     private ConnettoreFile_outputConfig outputFile = null;
  83.     private ConnettoreFile_outputConfig outputFileHeaders = null;
  84.     private boolean outputFileAutoCreateParentDirectory = false;
  85.     private boolean outputFileOverwriteIfExists = false;
  86.     private boolean generateResponse = false;
  87.     private File inputFile = null;
  88.     private File inputFileHeaders = null;
  89.     private boolean inputFileDeleteAfterRead = false;
  90.     private Integer inputFileWaitTimeIfNotExists;
  91.     
  92.     private ByteArrayOutputStream boutFileOutputHeaders;
  93.     
  94.     
  95.     /* Costruttori */
  96.     public ConnettoreFILE(){
  97.         
  98.     }

  100.     
  101.     
  102.     /* ********  METODI  ******** */

  104.     public String buildLocation(ConnettoreMsg request) throws ConnettoreException{
  105.         
  106.         this.properties = request.getConnectorProperties();
  107.         
  108.         // Costruisco Mappa per dynamic name
  109.         // NOTA: Lasciare la costruzione qua, poiche' altrimenti la classe File lancia eccezioni se trova i threshold
  110.         Map<String, Object> dynamicMap = this.buildDynamicMap(request);
  111.         
  112.         // OutputFile
  113.         String tmp = this.getDynamicProperty(request.getTipoConnettore(), true, CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE, dynamicMap);
  114.         File f = new File(tmp);
  115.         String l = f.getAbsolutePath();
  116.         
  117.         // OutputFile-Headers
  118.         tmp = this.getDynamicProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE_HEADERS, dynamicMap);
  119.         if(tmp!=null){
  120.             l = l + " [headers: "+(new File(tmp)).getAbsolutePath()+"]";
  121.         }
  122.         
  123.         return l;
  124.     }
  125.     

  127.     @Override
  128.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  129.         
  130.         if(this.initialize(request, true, responseCachingConfig)==false){
  131.             return false;
  132.         }
  133.         
  134.         return true;
  135.         
  136.     }
  137.     
  138.     @Override
  139.     protected boolean send(ConnettoreMsg request) {

  141.         // Lettura Parametri
  142.         try{
  143.     
  144.             this.checkContentType = true;
  145.             if(this.idModulo!=null){
  146.                 if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  147.                     this.checkContentType = this.openspcoopProperties.isControlloContentTypeAbilitatoRicezioneBuste();
  148.                 }else{
  149.                     this.checkContentType = this.openspcoopProperties.isControlloContentTypeAbilitatoRicezioneContenutiApplicativi();
  150.                 }
  151.             }
  152.             
  153.             
  154.             // Costruisco Mappa per dynamic name
  155.             Map<String, Object> dynamicMap = new HashMap<>();
  156.             DynamicInfo dInfo = new DynamicInfo(request, this.getPddContext());
  157.             DynamicUtils.fillDynamicMap(this.logger.getLogger(),dynamicMap, dInfo);
  158.             
  159.             
  160.             // Identificativo modulo
  161.             this.idModulo = request.getIdModulo();
  162.                     
  163.             // Context per invocazioni handler
  164.             this.outRequestContext = request.getOutRequestContext();
  165.             this.msgDiagnostico = request.getMsgDiagnostico();
  166.             
  167.             
  168.             // analsi i parametri specifici per il connettore
  169.             
  170.             // OutputFile
  171.             this.outputFile = readOutputConfig(request.getTipoConnettore(), true, 
  172.                     CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE, 
  173.                     CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE_PERMISSIONS);
  174.             if(this.outputFile==null || this.outputFile.getOutputFile()==null){
  175.                 return false;
  176.             }
  177.             
  178.             // OutputFileHeader
  179.             this.outputFileHeaders = readOutputConfig(request.getTipoConnettore(), false, 
  180.                     CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE_HEADERS, 
  181.                     CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_FILE_HEADERS_PERMISSIONS);

  183.             // Location
  184.             this.location = this.outputFile.getOutputFile().getAbsolutePath();
  185.             if(this.outputFileHeaders!=null){
  186.                 this.location = this.location + " [headers: "+this.outputFileHeaders.getOutputFile().getAbsolutePath()+"]";
  187.             }
  188.             
  189.             // AutoCreateDir
  190.             this.outputFileAutoCreateParentDirectory = this.isBooleanProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_AUTO_CREATE_DIR);
  191.             
  192.             // OverwriteFileIfExists
  193.             this.outputFileOverwriteIfExists = this.isBooleanProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_REQUEST_OUTPUT_OVERWRITE_FILE);
  194.             
  195.             // GenerazioneRisposta
  196.             this.generateResponse = this.isBooleanProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_RESPONSE_INPUT_MODE);
  197.             
  198.             if(this.generateResponse){
  199.                 
  200.                 // InputFile
  201.                 String tmp = this.getDynamicProperty(request.getTipoConnettore(), true, CostantiConnettori.CONNETTORE_FILE_RESPONSE_INPUT_FILE, dynamicMap);
  202.                 if(tmp==null){
  203.                     return false;
  204.                 }
  205.                 this.inputFile = new File(tmp);
  206.                 
  207.                 // InputFileHeader
  208.                 tmp = this.getDynamicProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_RESPONSE_INPUT_FILE_HEADERS, dynamicMap);
  209.                 if(tmp!=null){
  210.                     this.inputFileHeaders = new File(tmp);
  211.                 }
  212.                 
  213.                 // DeleteAfterRead
  214.                 this.inputFileDeleteAfterRead = this.isBooleanProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_RESPONSE_INPUT_FILE_DELETE_AFTER_READ);
  215.                 
  216.                 // inputFileWaitTimeIfNotExists
  217.                 this.inputFileWaitTimeIfNotExists = this.getIntegerProperty(request.getTipoConnettore(), false, CostantiConnettori.CONNETTORE_FILE_RESPONSE_INPUT_WAIT_TIME);
  218.             }
  219.             
  220.         }  catch(Exception e){ 
  221.             this.eccezioneProcessamento = e;
  222.             this.errore = "Errore avvenuto durante la consegna su FileSystem: "+this.readExceptionMessageFromException(e);
  223.             this.logger.error("Errore avvenuto durante la consegna su FileSystem: "+this.readExceptionMessageFromException(e),e);
  224.             return false;
  225.         } 
  226.             
  227.             
  228.             
  229.         // Gestione File
  230.         int readConnectionTimeout = -1;
  231.         boolean readConnectionTimeoutConfigurazioneGlobale = true;
  232.         try{

  234.             /* ------------  Request ------------- */
  235.             
  236.             
  237.             // OutputFile
  238.             this.checkOutputFile(this.outputFile, "Request");
  239.             
  240.             // OutputFile Headers
  241.             if(this.outputFileHeaders!=null){
  242.                 this.checkOutputFile(this.outputFileHeaders, "Request-Headers");
  243.             }
  244.             
  245.             
  246.             // Tipologia di servizio
  247.             MessageType requestMessageType = this.requestMsg.getMessageType();
  248.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  249.             if(this.debug)
  250.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  251.             if(this.isSoap){
  252.                 soapMessageRequest = this.requestMsg.castAsSoap();
  253.             }
  254.             
  255.             
  256.             
  257.             // Alcune implementazioni richiedono di aggiornare il Content-Type
  258.             this.requestMsg.updateContentType();
  259.             
  260.             
  261.             // Properties per serializzazione header file
  262.             this.boutFileOutputHeaders = new ByteArrayOutputStream();
  263.             
  264.             
  265.             // Collezione header di trasporto per dump
  266.             Map<String, List<String>> propertiesTrasportoDebug = null;
  267.             if(this.isDumpBinarioRichiesta()) {
  268.                 propertiesTrasportoDebug = new HashMap<>();
  269.             }
  270.             
  271.             
  272.             // Impostazione Content-Type
  273.             String contentTypeRichiesta = null;
  274.             if(this.debug)
  275.                 this.logger.debug("Impostazione content type...");
  276.             if(this.isSoap){
  277.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  278.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  279.                 }else{
  280.                     contentTypeRichiesta = this.requestMsg.getContentType();
  281.                 }
  282.                 if(contentTypeRichiesta==null){
  283.                     throw new Exception("Content-Type del messaggio da spedire non definito");
  284.                 }
  285.             }
  286.             else{
  287.                 contentTypeRichiesta = this.requestMsg.getContentType();
  288.                 // Content-Type non obbligatorio in REST
  289.             }
  290.             if(this.debug)
  291.                 this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  292.             if(contentTypeRichiesta!=null){
  293.                 setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, this.logger, propertiesTrasportoDebug);
  294.             }
  295.             
  296.             
  297.             
  298.             // Impostazione timeout
  299.             if(this.debug)
  300.                 this.logger.debug("Impostazione timeout...");
  301.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  302.                 try{
  303.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  304.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  305.                 }catch(Exception e){
  306.                     this.logger.error("Parametro "+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+" errato",e);
  307.                 }
  308.             }
  309.             if(readConnectionTimeout==-1){
  310.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  311.             }
  312.             if(this.debug)
  313.                 this.logger.info("Impostazione read timeout ["+readConnectionTimeout+"]",false);
  314.             
  315.             

  317.                 
  318.             // Impostazione Proprieta del trasporto
  319.             if(this.debug)
  320.                 this.logger.debug("Impostazione header di trasporto...");
  321.             this.forwardHttpRequestHeader();
  322.             if(this.propertiesTrasporto != null){
  323.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  324.                 while (keys.hasNext()) {
  325.                     String key = (String) keys.next();
  326.                     List<String> values = this.propertiesTrasporto.get(key);
  327.                     if(this.debug) {
  328.                         if(values!=null && !values.isEmpty()) {
  329.                             for (String value : values) {
  330.                                 this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  331.                             }
  332.                         }
  333.                     }
  334.                     
  335.                     setRequestHeader(key, values, this.logger, propertiesTrasportoDebug);
  336.                 }
  337.             }
  338.             
  339.             
  340.             
  341.             
  342.             
  343.             // Aggiunta del SoapAction Header in caso di richiesta SOAP
  344.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  345.             if(this.isSoap && this.sbustamentoSoap == false){
  346.                 if(this.debug)
  347.                     this.logger.debug("Impostazione soap action...");
  348.                 boolean existsTransportProperties = false;
  349.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  350.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  351.                     existsTransportProperties = (this.soapAction!=null);
  352.                 }
  353.                 if(!existsTransportProperties) {
  354.                     this.soapAction = soapMessageRequest.getSoapAction();
  355.                 }
  356.                 if(this.soapAction==null){
  357.                     this.soapAction="\"OpenSPCoop\"";
  358.                 }
  359.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  360.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  361.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, this.logger, propertiesTrasportoDebug);
  362.                 }
  363.                 if(this.debug)
  364.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  365.             }
  366.             
  367.             
  368.             
  369.             
  370.                     
  371.             // Spedizione byte
  372.             boolean consumeRequestMessage = true;
  373.             if(this.debug)
  374.                 this.logger.debug("Serializzazione ["+this.outputFile.getOutputFile().getAbsolutePath()+"] (consume-request-message:"+consumeRequestMessage+")...");
  375.             OutputStream out = new FileOutputStream(this.outputFile.getOutputFile());
  376.             if(this.isDumpBinarioRichiesta()) {
  377.                 DumpByteArrayOutputStream bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  378.                         TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  379.                 try {
  380.                     this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  381.                     
  382.                     if(this.isSoap && this.sbustamentoSoap){
  383.                         this.logger.debug("Sbustamento...");
  384.                         TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,bout);
  385.                     }else{
  386.                         this.requestMsg.writeTo(bout, consumeRequestMessage);
  387.                     }
  388.                     bout.flush();
  389.                     bout.close();
  390.                     
  391.                     if(bout.isSerializedOnFileSystem()) {
  392.                         try(FileInputStream fin = new FileInputStream(bout.getSerializedFile())) {
  393.                             Utilities.copy(fin, out);
  394.                         }
  395.                     }
  396.                     else {
  397.                         out.write(bout.toByteArray());
  398.                     }
  399.                     
  400.                     out.flush();
  401.                     out.close();
  402.                     
  403.                     this.dataRichiestaInoltrata = DateManager.getDate();
  404.                     
  405.                     this.dumpBinarioRichiestaUscita(bout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  406.                 }finally {
  407.                     try {
  408.                         bout.clearResources();
  409.                     }catch(Throwable t) {
  410.                         this.logger.error("Release resources failed: "+t.getMessage(),t);
  411.                     }
  412.                 }
  413.             }else{
  414.                 if(this.isSoap && this.sbustamentoSoap){
  415.                     if(this.debug)
  416.                         this.logger.debug("Sbustamento...");
  417.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,out);
  418.                 }else{
  419.                     this.requestMsg.writeTo(out, consumeRequestMessage);
  420.                 }
  421.                 
  422.                 out.flush();
  423.                 out.close();
  424.                 
  425.                 this.dataRichiestaInoltrata = DateManager.getDate();
  426.             }

  428.             if(this.debug)
  429.                 this.logger.debug("Serializzazione ["+this.outputFile.getOutputFile().getAbsolutePath()+"] effettuata");
  430.             
  431.             if(this.outputFile.isPermission()) {
  432.                 if(this.debug)
  433.                     this.logger.debug("Modifica diritti del file ["+this.outputFile.getOutputFile().getAbsolutePath()+"] ("+this.outputFile.getPermissionAsString()+") ...");
  434.                 setPermission(this.outputFile);
  435.                 if(this.debug)
  436.                     this.logger.debug("Modifica diritti del file ["+this.outputFile.getOutputFile().getAbsolutePath()+"] ("+this.outputFile.getPermissionAsString()+") effettuata");
  437.             }
  438.             
  439.             
  440.             // Spedizione File Headers
  441.             this.boutFileOutputHeaders.flush();
  442.             this.boutFileOutputHeaders.close();
  443.             if(this.outputFileHeaders!=null){
  444.                 if(this.debug)
  445.                     this.logger.debug("Serializzazione File Output Headers ["+this.outputFileHeaders.getOutputFile().getAbsolutePath()+"]...");
  446.                 out = new FileOutputStream(this.outputFileHeaders.getOutputFile());
  447.                 if(this.debug){
  448.                     ByteArrayOutputStream bout = new ByteArrayOutputStream();
  449.                     bout.write(this.boutFileOutputHeaders.toByteArray());
  450.                     bout.flush();
  451.                     bout.close();
  452.                     out.write(bout.toByteArray());
  453.                     this.logger.info("File Header Serializzato:\n"+bout.toString(),false);
  454.                 }else{
  455.                     out.write(this.boutFileOutputHeaders.toByteArray());
  456.                 }
  457.                 out.flush();
  458.                 out.close();
  459.                 if(this.debug)
  460.                     this.logger.debug("Serializzazione File Output Headers ["+this.outputFileHeaders.getOutputFile().getAbsolutePath()+"] effettuata");
  461.                 
  462.                 if(this.outputFileHeaders.isPermission()) {
  463.                     if(this.debug)
  464.                         this.logger.debug("Modifica diritti del file ["+this.outputFileHeaders.getOutputFile().getAbsolutePath()+"] ("+this.outputFileHeaders.getPermissionAsString()+") ...");
  465.                     setPermission(this.outputFileHeaders);
  466.                     if(this.debug)
  467.                         this.logger.debug("Modifica diritti del file ["+this.outputFileHeaders.getOutputFile().getAbsolutePath()+"] ("+this.outputFileHeaders.getPermissionAsString()+") effettuata");
  468.                 }
  469.             }
  470.             

  472.             
  473.             
  474.             
  475.             /* ------------  PostOutRequestHandler ------------- */
  476.             this.postOutRequest();
  477.             
  478.             
  479.             
  480.             
  481.             // return code
  482.             this.codice = 200; // codice deve essere impostato prima delle invocazioni dei successivi metodi nel caso di gestione response, altrimenti cmq ho finito
  483.             

  485.             
  486.             if(this.generateResponse){

  488.                 
  489.                 
  490.                 /* ------------  PreInResponseHandler ------------- */
  491.                 this.preInResponse();
  492.                 
  493.                 // Lettura risposta parametri NotifierInputStream per la risposta
  494.                 this.notifierInputStreamParams = null;
  495.                 if(this.preInResponseContext!=null){
  496.                     this.notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  497.                 }

  499.                 
  500.                 
  501.                 
  502.                 
  503.                 
  504.                 /* ------------  Response ------------- */
  505.                 
  506.                 // InputFile
  507.                 this.checkInputFile(this.inputFile, "Response");
  508.                 
  509.                 // InputFile Header
  510.                 if(this.inputFileHeaders!=null){
  511.                     this.checkInputFile(this.inputFileHeaders, "Response-Headers");
  512.                     this.propertiesTrasportoRisposta = new HashMap<>();
  513.                     FileInputStream fin = new FileInputStream(this.inputFileHeaders);
  514.                     try{
  515.                         Properties pTmp = new Properties();
  516.                         pTmp.load(fin);
  517.                         if(pTmp.size()>0) {
  518.                             Enumeration<Object> en = pTmp.keys();
  519.                             while (en.hasMoreElements()) {
  520.                                 Object oKey = (Object) en.nextElement();
  521.                                 if(oKey instanceof String) {
  522.                                     String key = (String) oKey;
  523.                                     String value = pTmp.getProperty(key);
  524.                                     TransportUtils.addHeader(this.propertiesTrasportoRisposta, key, value);             
  525.                                 }
  526.                             }
  527.                             
  528.                         }
  529.                     }
  530.                     catch(Exception e){
  531.                         throw new Exception("Input File (Response-Headers) ["+this.inputFileHeaders.getAbsolutePath()+"] with wrong format: "+e.getMessage(),e);
  532.                     }
  533.                     finally{
  534.                         try{
  535.                             if(fin!=null){
  536.                                 fin.close();
  537.                             }
  538.                         }catch(Exception eClose){
  539.                             // close
  540.                         }
  541.                     }
  542.                 }
  543.         
  544.                 
  545.                 // Dati Risposta
  546.                 if(this.debug)
  547.                     this.logger.debug("Analisi risposta...");
  548.                 if(this.propertiesTrasportoRisposta!=null && this.propertiesTrasportoRisposta.size()>0){            
  549.                     this.tipoRisposta = TransportUtils.getFirstValue(this.propertiesTrasportoRisposta, HttpConstants.CONTENT_TYPE); 
  550.                 }
  551.                 if(this.tipoRisposta==null || "".equals(this.tipoRisposta)) {
  552.                     this.tipoRisposta = contentTypeRichiesta;
  553.                     if(this.propertiesTrasportoRisposta==null) {
  554.                         this.propertiesTrasportoRisposta = new HashMap<>();
  555.                     }
  556.                     TransportUtils.setHeader(this.propertiesTrasportoRisposta, HttpConstants.CONTENT_TYPE, this.tipoRisposta);
  557.                 }

  559.                                 
  560.                 // Parametri di imbustamento
  561.                 if(this.isSoap){
  562.                     this.imbustamentoConAttachment = false;
  563.                     if(this.propertiesTrasportoRisposta!=null && this.propertiesTrasportoRisposta.size()>0){
  564.                         if("true".equals(TransportUtils.getObjectAsString(this.propertiesTrasportoRisposta, this.openspcoopProperties.getTunnelSOAPKeyWord_headerTrasporto()))){
  565.                             this.imbustamentoConAttachment = true;
  566.                         }
  567.                         this.mimeTypeAttachment = TransportUtils.getFirstValue(this.propertiesTrasportoRisposta, this.openspcoopProperties.getTunnelSOAPKeyWordMimeType_headerTrasporto());
  568.                         if(this.mimeTypeAttachment==null)
  569.                             this.mimeTypeAttachment = HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP;
  570.                         //System.out.println("IMB["+imbustamentoConAttachment+"] MIME["+mimeTypeAttachment+"]");
  571.                     }
  572.                 }
  573.                 
  574.                 
  575.                 // Gestione risposta
  576.                 
  577.                 this.isResponse = new FileInputStream(this.inputFile);
  578.                                 
  579.                 this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  580.                 
  581.                 this.initCheckContentTypeConfiguration();
  582.                 
  583.                 if(this.isDumpBinarioRisposta()){
  584.                     this.dumpResponse(this.propertiesTrasportoRisposta);
  585.                 }
  586.                                 
  587.                 if(this.isRest){
  588.                     
  589.                     if(this.doRestResponse()==false){
  590.                         return false;
  591.                     }
  592.                     
  593.                 }
  594.                 else{
  595.                 
  596.                     if(this.doSoapResponse()==false){
  597.                         return false;
  598.                     }
  599.                     
  600.                 }
  601.                 
  602.             }


  605.             if(this.debug)
  606.                 this.logger.info("Gestione consegna su file effettuata con successo",false);
  607.             
  608.             return true;

  610.         }  catch(Exception e){ 
  611.             this.eccezioneProcessamento = e;
  612.             String msgErrore = this.readExceptionMessageFromException(e);
  613.             if(this.generateErrorWithConnectorPrefix) {
  614.                 this.errore = "Errore avvenuto durante la consegna su FileSystem: "+msgErrore;
  615.             }
  616.             else {
  617.                 this.errore = msgErrore;
  618.             }
  619.             this.logger.error("Errore avvenuto durante la consegna su FileSystem: "+msgErrore,e);
  620.             
  621.             /**this.processConnectionTimeoutException(connectionTimeout, e, msgErrore);*/
  622.             
  623.             this.processReadTimeoutException(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale, e, msgErrore);
  624.             
  625.             return false;
  626.         } 
  627.     }
  628.     
  629.     /**
  630.      * Effettua la disconnessione 
  631.      */
  632.     @Override
  633.     public void disconnect() throws ConnettoreException{
  634.         List<Throwable> listExceptionChiusura = new ArrayList<Throwable>();
  635.         try{
  636.         
  637.             // Gestione finale
  638.             
  639.             if(this.isResponse!=null){
  640.                 if(this.debug && this.logger!=null)
  641.                     this.logger.debug("Chiusura inputStream ["+this.inputFile.getAbsolutePath()+"] ...");
  642.                 try{
  643.                     this.isResponse.close();
  644.                     if(this.debug && this.logger!=null)
  645.                         this.logger.debug("Chiusura inputStream ["+this.inputFile.getAbsolutePath()+"] effettuata con successo");
  646.                 }catch(Throwable e){
  647.                     if(this.logger!=null)
  648.                         this.logger.error("Chiusura inputStream ["+this.inputFile.getAbsolutePath()+"] non riuscita");
  649.                     listExceptionChiusura.add(e);
  650.                 }
  651.             }
  652.             
  653.             if(this.inputFile!=null && this.inputFileDeleteAfterRead && this.inputFile.exists()){
  654.                 if(this.debug && this.logger!=null)
  655.                     this.logger.debug("Eliminazione File ["+this.inputFile.getAbsolutePath()+"] ...");
  656.                 if(this.inputFile.delete()){
  657.                     if(this.debug && this.logger!=null)
  658.                         this.logger.debug("Eliminazione File ["+this.inputFile.getAbsolutePath()+"] effettuata con successo");
  659.                 }
  660.                 else{
  661.                     if(this.logger!=null)
  662.                         this.logger.error("Eliminazione File ["+this.inputFile.getAbsolutePath()+"] non riuscita");
  663.                 }
  664.             }
  665.             
  666.             // Gestione finale della connessione
  667.             if(this.inputFileHeaders!=null && this.inputFileDeleteAfterRead && this.inputFileHeaders.exists()){
  668.                 if(this.debug && this.logger!=null)
  669.                     this.logger.debug("Eliminazione File ["+this.inputFileHeaders.getAbsolutePath()+"] ...");
  670.                 if(this.inputFileHeaders.delete()){
  671.                     if(this.debug && this.logger!=null)
  672.                         this.logger.debug("Eliminazione File ["+this.inputFileHeaders.getAbsolutePath()+"] effettuata con successo");
  673.                 }
  674.                 else{
  675.                     if(this.logger!=null)
  676.                         this.logger.error("Eliminazione File ["+this.inputFileHeaders.getAbsolutePath()+"] non riuscita");
  677.                 }
  678.             }
  679.     

  681.             
  682.             // super.disconnect (Per risorse base)
  683.             try {
  684.                 super.disconnect();
  685.             }catch(Throwable t) {
  686.                 this.logger.debug("Chiusura risorse fallita: "+t.getMessage(),t);
  687.                 listExceptionChiusura.add(t);
  688.             }
  689.             
  690.         }catch(Exception e){
  691.             throw new ConnettoreException("Chiusura non riuscita: "+e.getMessage(),e);
  692.         }
  693.         
  694.         if(listExceptionChiusura!=null && !listExceptionChiusura.isEmpty()) {
  695.             org.openspcoop2.utils.UtilsMultiException multiException = new org.openspcoop2.utils.UtilsMultiException(listExceptionChiusura.toArray(new Throwable[1]));
  696.             throw new ConnettoreException("Chiusura connessione non riuscita: "+multiException.getMessage(),multiException);
  697.         }
  698.     }

  700.     
  701.     /**
  702.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  703.      * 
  704.      * @return location di inoltro del messaggio
  705.      */
  706.     @Override
  707.     public String getLocation(){
  708.         return this.location;
  709.     }


  712.     private void setRequestHeader(String key, String value, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  713.         List<String> list = new ArrayList<>(); 
  714.         list.add(value);
  715.         this.setRequestHeader(key, list, logger, propertiesTrasportoDebug);
  716.     }
  717.     private void setRequestHeader(String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  718.         
  719.         if(this.debug) {
  720.             if(values!=null && !values.isEmpty()) {
  721.                 for (String value : values) {
  722.                     this.logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);        
  723.                 }
  724.             }
  725.         }
  726.         setRequestHeader(key, values, propertiesTrasportoDebug);
  727.         
  728.     }
  729.     
  730.     @Override
  731.     protected void setRequestHeader(String key,List<String> values) throws Exception{
  732.         if(values!=null && !values.isEmpty()) {
  733.             for (String value : values) {
  734.                 this.boutFileOutputHeaders.write((key+"="+value+"\n").getBytes());      
  735.             }
  736.         } 
  737.     }
  738.     
  739.     
  740.     private void checkOutputFile(ConnettoreFile_outputConfig fileConfig, String tipo) throws Exception{
  741.         File file = fileConfig.getOutputFile();
  742.         if(this.debug){
  743.             this.logger.debug("Check file output ("+tipo+") ["+file.getAbsolutePath()+"]...");
  744.         }
  745.         if(file.exists()){
  746.             if(this.debug){
  747.                 this.logger.debug("File output ("+tipo+") ["+file.getAbsolutePath()+"] exists canRead["+file.canRead()+
  748.                     "] canWrite["+file.canWrite()+"] canExcute["+file.canExecute()+"] isDirectory["+
  749.                     file.isDirectory()+"] isFile["+file.isFile()+"] isHidden["+file.isHidden()+"]");    
  750.             }
  751.             if(this.outputFileOverwriteIfExists==false){
  752.                 throw new Exception("Output File ("+tipo+") ["+file.getAbsolutePath()+"] already exists (overwrite not permitted)");
  753.             }
  754.             if(file.isFile()==false){
  755.                 throw new Exception("Output File ("+tipo+") ["+file.getAbsolutePath()+"] already exists with uncorrect type (is Directory?)");
  756.             }
  757.             if(file.canWrite()==false){
  758.                 throw new Exception("Output File ("+tipo+") ["+file.getAbsolutePath()+"] already exists (cannot rewrite)");
  759.             }
  760.         }
  761.         if(this.debug){
  762.             this.logger.debug("("+tipo+") Check parent directory ...");
  763.         }
  764.         if(file.getParentFile()!=null){
  765.             if(this.debug){
  766.                 this.logger.debug("("+tipo+") Check parent directory ["+file.getParentFile().getAbsolutePath()+"] ...");
  767.             }
  768.             if(file.getParentFile().exists()==false){
  769.                 if(this.outputFileAutoCreateParentDirectory==false){
  770.                     throw new Exception("Parent Directory Output File ("+tipo+") ["+file.getParentFile().getAbsolutePath()+"] not exists (auto create not permitted)");
  771.                 }
  772.                 FileSystemUtilities.mkdirParentDirectory(file,
  773.                         fileConfig.getReadable(), fileConfig.getReadable_ownerOnly(),
  774.                         fileConfig.getWritable(), fileConfig.getWritable_ownerOnly(),
  775.                         fileConfig.getExecutable(), fileConfig.getExecutable_ownerOnly());
  776.             }
  777.             else{
  778.                 if(this.debug){
  779.                     this.logger.debug("Parent Directory Output File ("+tipo+") ["+file.getParentFile().getAbsolutePath()+"] exists canRead["+file.getParentFile().canRead()+
  780.                         "] canWrite["+file.getParentFile().canWrite()+"] canExcute["+file.getParentFile().canExecute()+"] isDirectory["+
  781.                         file.getParentFile().isDirectory()+"] isFile["+file.getParentFile().isFile()+"] isHidden["+file.getParentFile().isHidden()+"]");    
  782.                 }
  783.                 if(file.getParentFile().isDirectory()==false){
  784.                     throw new Exception("Parent Directory Output File ("+tipo+") ["+file.getParentFile().getAbsolutePath()+"] already exists with uncorrect type (is File?)");
  785.                 }
  786.                 if(file.getParentFile().canWrite()==false){
  787.                     throw new Exception("Parent Directory Output File ("+tipo+") ["+file.getParentFile().getAbsolutePath()+"] already exists (cannot rewrite)");
  788.                 }
  789.             }
  790.         }
  791.     }
  792.     
  793.     private void checkInputFile(File file, String tipo) throws Exception{
  794.         if(this.debug){
  795.             this.logger.debug("Check file input ("+tipo+") ["+file.getAbsolutePath()+"]...");
  796.         }
  797.         if(file.exists()){
  798.             this._checkInputFile(file, tipo);
  799.         }
  800.         else{
  801.             
  802.             if(this.inputFileWaitTimeIfNotExists!=null && this.inputFileWaitTimeIfNotExists>0){
  803.                 
  804.                 int millisecond = this.inputFileWaitTimeIfNotExists;
  805.                 int tempoSingoloSleepMs = 250;
  806.                 if(millisecond>tempoSingoloSleepMs){
  807.                     int count = millisecond/tempoSingoloSleepMs;
  808.                     int resto = millisecond%tempoSingoloSleepMs;
  809.                     this.logger.info("Wait "+millisecond+"ms ...", false);
  810.                     for (int i = 0; i < count; i++) {
  811.                         Utilities.sleep(tempoSingoloSleepMs);
  812.                         if(file.exists()){
  813.                             break;
  814.                         }
  815.                     }
  816.                     if(!file.exists()){
  817.                         Utilities.sleep(resto);
  818.                     }
  819.                     this.logger.info("Wait "+millisecond+"ms terminated", false);
  820.                 }else{
  821.                     this.logger.info("Wait "+millisecond+"ms ...", false);
  822.                     Utilities.sleep(tempoSingoloSleepMs);
  823.                     this.logger.info("Wait "+millisecond+"ms terminated", false);
  824.                 }
  825.                 
  826.                 if(file.exists()){
  827.                     this._checkInputFile(file, tipo);
  828.                 }
  829.                 else{
  830.                     throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] not exists (wait "+millisecond+"ms)");
  831.                 }
  832.             }
  833.             else{
  834.                 throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] not exists");
  835.             }
  836.         }
  837.     }
  838.     private void _checkInputFile(File file, String tipo) throws Exception{
  839.         if(this.debug){
  840.             this.logger.debug("File input ("+tipo+") ["+file.getAbsolutePath()+"] exists canRead["+file.canRead()+
  841.                 "] canWrite["+file.canWrite()+"] canExcute["+file.canExecute()+"] isDirectory["+
  842.                 file.isDirectory()+"] isFile["+file.isFile()+"] isHidden["+file.isHidden()+"] lenght["+file.length()+"]");  
  843.         }
  844.         if(file.isFile()==false){
  845.             throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] with uncorrect type (is Directory?)");
  846.         }
  847.         if(file.canRead()==false){
  848.             throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] cannot read");
  849.         }
  850.         if(file.length()<=0){
  851.             throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] empty");
  852.         }
  853.         if(this.inputFileDeleteAfterRead){
  854.             if(file.canWrite()==false){
  855.                 throw new Exception("Input File ("+tipo+") ["+file.getAbsolutePath()+"] cannot write (delete after read required)");
  856.             }
  857.         }
  858.     }

  860.     private ConnettoreFile_outputConfig readOutputConfig(String tipoConnettore,boolean required, String file, String permission) throws ConnettoreException {
  861.         String tmp = this.getDynamicProperty(tipoConnettore, required, file, this.dynamicMap);
  862.         if(tmp==null){
  863.             return null;
  864.         }
  865.         ConnettoreFile_outputConfig c = new ConnettoreFile_outputConfig();
  866.         c.setOutputFile(new File(tmp));
  867.         
  868.         String p = this.getDynamicProperty(tipoConnettore, false, permission, this.dynamicMap);
  869.         if(p!=null) {
  870.              validatePermission(p, c);
  871.         }
  872.         return c;
  873.     }
  874.     
  875.     public static void validatePermission(String p, ConnettoreFile_outputConfig c) throws ConnettoreException {
  876.         Scanner scanner = new Scanner(p);
  877.         try {
  878.             while (scanner.hasNextLine()) {
  879.                 String line = scanner.nextLine();
  880.                 if(line==null || line.trim().equals("") || line.trim().startsWith("#")) {
  881.                     continue;
  882.                 }
  883.                 _validateSinglePermission(line,c);
  884.             }
  885.         }finally {
  886.             scanner.close();
  887.         }
  888.     }
  889.     
  890.     public static int getNumPermission(String p) throws ConnettoreException {
  891.         Scanner scanner = new Scanner(p);
  892.         int num = 0;
  893.         try {
  894.             while (scanner.hasNextLine()) {
  895.                 String line = scanner.nextLine();
  896.                 if(line==null || line.trim().equals("") || line.trim().startsWith("#")) {
  897.                     continue;
  898.                 }
  899.                 num++;
  900.             }
  901.             return num;
  902.         }finally {
  903.             scanner.close();
  904.         }
  905.     }
  906.     
  907.     public static final String PERMESSI_FORMATO = "[o/a]+/-rwx";
  908.     private static void _validateSinglePermission(String p, ConnettoreFile_outputConfig config) throws ConnettoreException {
  909.         String errorMsg = "Wrong permission format ("+p+"); expected "+PERMESSI_FORMATO;
  910.         if(p==null || StringUtils.isEmpty(p) || (!p.contains("+") && !p.contains("-")) || p.length()<=1) {
  911.             throw new ConnettoreException(errorMsg);
  912.         }
  913.         
  914.         String permission = null;
  915.         boolean add = false;
  916.         Boolean owner = null;
  917.         if(p.startsWith("+")) {
  918.             permission = p.substring(1);
  919.             add = true;
  920.         }
  921.         else if(p.startsWith("-")) {
  922.             permission = p.substring(1);
  923.             add = false;
  924.         }
  925.         else if(p.contains("+")) {
  926.             add = true;
  927.             int indexOf = p.indexOf("+");
  928.             String ownerS = p.substring(0, indexOf);
  929.             if(!"o".equals(ownerS) && !"a".equals(ownerS)) {
  930.                 throw new ConnettoreException(errorMsg);
  931.             }
  932.             if("o".equals(ownerS)) {
  933.                 owner = true;
  934.             }
  935.             else if("a".equals(ownerS)) {
  936.                 owner = false;
  937.             }
  938.             if(indexOf == (p.length()-1)) {
  939.                 throw new ConnettoreException(errorMsg);
  940.             }
  941.             permission = p.substring(indexOf+1, p.length());
  942.         }
  943.         else if(p.contains("-")) {
  944.             add = false;
  945.             int indexOf = p.indexOf("-");
  946.             String ownerS = p.substring(0, indexOf);
  947.             if(!"o".equals(ownerS) && !"a".equals(ownerS)) {
  948.                 throw new ConnettoreException(errorMsg);
  949.             }
  950.             if("o".equals(ownerS)) {
  951.                 owner = true;
  952.             }
  953.             else if("a".equals(ownerS)) {
  954.                 owner = false;
  955.             }
  956.             if(indexOf == (p.length()-1)) {
  957.                 throw new ConnettoreException(errorMsg);
  958.             }
  959.             permission = p.substring(indexOf+1, p.length());
  960.         }
  961.         
  962.         if(permission!=null) {
  963.             for (int i = 0; i < permission.length(); i++) {
  964.                 char c = permission.charAt(i);
  965.                 if(c == 'r' || c == 'R') {
  966.                     config.setReadable(add);
  967.                     if(owner!=null) {
  968.                         config.setReadable_ownerOnly(owner);
  969.                     }
  970.                 }
  971.                 else if(c == 'w' || c == 'W') {
  972.                     config.setWritable(add);
  973.                     if(owner!=null) {
  974.                         config.setWritable_ownerOnly(owner);
  975.                     }
  976.                 }
  977.                 else if(c == 'x' || c == 'X') {
  978.                     config.setExecutable(add);
  979.                     if(owner!=null) {
  980.                         config.setExecutable_ownerOnly(owner);
  981.                     }
  982.                 }
  983.                 else {
  984.                     throw new ConnettoreException(errorMsg);
  985.                 }
  986.             }
  987.         }
  988.         
  989.     }
  990.     
  991.     private void setPermission(ConnettoreFile_outputConfig config) throws ConnettoreException {
  992.         if(config.getReadable()!=null) {
  993.             if(config.getReadable_ownerOnly()!=null) {
  994.                 if(!config.getOutputFile().setReadable(config.getReadable(), config.getReadable_ownerOnly())) {
  995.                     // ignore
  996.                 }
  997.             }
  998.             else {
  999.                 if(!config.getOutputFile().setReadable(config.getReadable())) {
  1000.                     // ignore
  1001.                 }
  1002.             }
  1003.         }
  1004.         if(config.getWritable()!=null) {
  1005.             if(config.getWritable_ownerOnly()!=null) {
  1006.                 if(!config.getOutputFile().setWritable(config.getWritable(), config.getWritable_ownerOnly())) {
  1007.                     // ignore
  1008.                 }
  1009.             }
  1010.             else {
  1011.                 if(!config.getOutputFile().setWritable(config.getWritable())) {
  1012.                     // ignore
  1013.                 }
  1014.             }
  1015.         }
  1016.         if(config.getExecutable()!=null) {
  1017.             if(config.getExecutable_ownerOnly()!=null) {
  1018.                 if(!config.getOutputFile().setExecutable(config.getExecutable(), config.getExecutable_ownerOnly())) {
  1019.                     // ignore
  1020.                 }
  1021.             }
  1022.             else {
  1023.                 if(!config.getOutputFile().setExecutable(config.getExecutable())) {
  1024.                     // ignore
  1025.                 }
  1026.             }
  1027.         }
  1028.     }
  1029. }





Created with JaCoCo 0.8.8.202204050719