FileTraceManager.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.  */
  20. package org.openspcoop2.pdd.logger.filetrace;

  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;

  27. import org.apache.commons.lang.StringUtils;
  28. import org.openspcoop2.core.constants.Costanti;
  29. import org.openspcoop2.core.constants.TipoPdD;
  30. import org.openspcoop2.core.transazioni.Transazione;
  31. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  32. import org.openspcoop2.core.transazioni.utils.CredenzialiMittente;
  33. import org.openspcoop2.monitor.sdk.transaction.FaseTracciamento;
  34. import org.openspcoop2.pdd.core.token.InformazioniNegoziazioneToken;
  35. import org.openspcoop2.pdd.core.token.InformazioniToken;
  36. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  37. import org.openspcoop2.pdd.core.transazioni.Transaction;
  38. import org.openspcoop2.protocol.sdk.Busta;
  39. import org.openspcoop2.protocol.sdk.Context;
  40. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  41. import org.openspcoop2.protocol.sdk.ProtocolException;
  42. import org.openspcoop2.protocol.sdk.SecurityToken;
  43. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  44. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  45. import org.openspcoop2.utils.DynamicStringReplace;
  46. import org.openspcoop2.utils.UtilsException;
  47. import org.slf4j.Logger;

  49. /**     
  50.  * TransazioneLogTraceManager
  51.  *
  52.  * @author Poli Andrea (poli@link.it)
  53.  * @author $Author$
  54.  * @version $Rev$, $Date$
  55.  */
  56. public class FileTraceManager {
  57.     
  58.     private Logger log;
  59.     private FileTraceConfig config;
  60.     
  61.     private Map<String, Object> dynamicMap = new HashMap<>();
  62.     private Info t;
  63.     private Info tBase64;
  64.     

  66.     public FileTraceManager(Logger log, FileTraceConfig config) {
  67.         this.config = config;
  68.         this.log = log;
  69.     }
  70.     
  71.     public void buildTransazioneInfo(IProtocolFactory<?> protocolFactory, Transazione transazioneDTO, Transaction transaction, 
  72.             InformazioniToken informazioniToken,
  73.             InformazioniAttributi informazioniAttributi,
  74.             InformazioniNegoziazioneToken informazioniNegoziazioneToken,
  75.             SecurityToken securityToken,
  76.             Context context,
  77.             Map<String, List<String>> headerInUscita,
  78.             FaseTracciamento trackingPhase) throws ProtocolException {
  79.         
  80.         Messaggio richiestaIngresso = null;
  81.         Messaggio richiestaUscita = null;
  82.         Messaggio rispostaIngresso = null;
  83.         Messaggio rispostaUscita = null;
  84.         
  85.         for(int i=0; i<transaction.sizeMessaggi(); i++){
  86.             Messaggio messaggio = transaction.getMessaggio(i);
  87.             TipoMessaggio tipoMessaggio = messaggio.getTipoMessaggio();
  88.             switch (tipoMessaggio) {
  89.             case RICHIESTA_INGRESSO_DUMP_BINARIO:
  90.                 richiestaIngresso = messaggio;
  91.                 break;
  92.             case RICHIESTA_USCITA_DUMP_BINARIO:
  93.                 richiestaUscita = messaggio;
  94.                 break;
  95.             case RISPOSTA_INGRESSO_DUMP_BINARIO:
  96.                 rispostaIngresso = messaggio;
  97.                 break;
  98.             case RISPOSTA_USCITA_DUMP_BINARIO:
  99.                 rispostaUscita = messaggio;
  100.                 break;
  101.             default:
  102.                 break;
  103.             }
  104.             
  105.         }
  106.         
  107.         Map<String, List<String>> headerRichiestaUscita = null;
  108.         Map<String, List<String>> headerRispostaUscita = null;
  109.         if(FaseTracciamento.OUT_REQUEST.equals(trackingPhase)) {
  110.             headerRichiestaUscita = headerInUscita;
  111.         }
  112.         else if(FaseTracciamento.OUT_RESPONSE.equals(trackingPhase)) {
  113.             headerRispostaUscita = headerInUscita;
  114.         }
  115.         
  116.         CredenzialiMittente credenzialiMittente = transaction.getCredenzialiMittente();
  117.         
  118.         InfoConfigurazione infoConfigurazione = new InfoConfigurazione(transazioneDTO, context, credenzialiMittente);
  119.         
  120.         boolean base64 = true;
  121.         
  122.         this.t = new Info(this.log, protocolFactory, transazioneDTO, credenzialiMittente, 
  123.                 informazioniToken,
  124.                 informazioniAttributi,
  125.                 informazioniNegoziazioneToken,
  126.                 securityToken,
  127.                 transaction.getTracciaRichiesta(), transaction.getTracciaRisposta(),
  128.                 transaction.getMsgDiagnostici(),
  129.                 richiestaIngresso, 
  130.                 richiestaUscita, headerRichiestaUscita,
  131.                 rispostaIngresso, 
  132.                 rispostaUscita, headerRispostaUscita,
  133.                 infoConfigurazione,
  134.                 this.config, trackingPhase, 
  135.                 !base64);
  136.         this.tBase64 = new Info(this.log, protocolFactory, transazioneDTO, credenzialiMittente, 
  137.                 informazioniToken,
  138.                 informazioniAttributi,
  139.                 informazioniNegoziazioneToken,
  140.                 securityToken,
  141.                 transaction.getTracciaRichiesta(), transaction.getTracciaRisposta(),
  142.                 transaction.getMsgDiagnostici(),
  143.                 richiestaIngresso, 
  144.                 richiestaUscita, headerRichiestaUscita,
  145.                 rispostaIngresso, 
  146.                 rispostaUscita, headerRispostaUscita,
  147.                 infoConfigurazione, 
  148.                 this.config, trackingPhase,  
  149.                 base64);
  150.         
  151.         this.dynamicMap.put("log", this.t);
  152.         this.dynamicMap.put("logBase64", this.tBase64);
  153.         
  154.     }
  155.         
  156.     public void cleanResourcesForOnlyFileTrace(Transaction transaction) throws ProtocolException {
  157.             
  158.         List<TipoMessaggio> tipiDaEliminareHeaders = transaction.getMessaggiHeadersOnlyLogFileTrace();
  159.         List<TipoMessaggio> tipiDaEliminareBody = transaction.getMessaggiBodyOnlyLogFileTrace();
  160.             
  161.         List<TipoMessaggio> messaggiDaEliminare = new ArrayList<>();
  162.         
  163.         for(int i=0; i<transaction.sizeMessaggi(); i++){
  164.             Messaggio messaggio = transaction.getMessaggio(i);
  165.             TipoMessaggio tipoMessaggio = messaggio.getTipoMessaggio();
  166.             
  167.             boolean onlyLogFileTraceHeaders = false;
  168.             if(tipiDaEliminareHeaders!=null && !tipiDaEliminareHeaders.isEmpty()) {
  169.                 for (int j = 0; j < tipiDaEliminareHeaders.size(); j++) {
  170.                     TipoMessaggio tipoMessaggioHeaders = tipiDaEliminareHeaders.get(j);
  171.                     if(tipoMessaggioHeaders.equals(tipoMessaggio)) {
  172.                         onlyLogFileTraceHeaders = true;
  173.                         break;
  174.                     }
  175.                 }
  176.             }
  177.             if(onlyLogFileTraceHeaders) {
  178.                 tipiDaEliminareHeaders.remove(tipoMessaggio);   
  179.             }
  180.             
  181.             boolean onlyLogFileTraceBody = false;
  182.             if(tipiDaEliminareBody!=null && !tipiDaEliminareBody.isEmpty()) {
  183.                 for (int j = 0; j < tipiDaEliminareBody.size(); j++) {
  184.                     TipoMessaggio tipoMessaggioBody = tipiDaEliminareBody.get(j);
  185.                     if(tipoMessaggioBody.equals(tipoMessaggio)) {
  186.                         onlyLogFileTraceBody = true;
  187.                         break;
  188.                     }
  189.                 }
  190.             }
  191.             if(onlyLogFileTraceBody) {
  192.                 tipiDaEliminareBody.remove(tipoMessaggio);  
  193.             }
  194.             
  195.             if(onlyLogFileTraceHeaders && onlyLogFileTraceBody) {
  196.                 messaggiDaEliminare.add(tipoMessaggio);
  197.             }
  198.             else if(onlyLogFileTraceHeaders) {
  199.                 messaggio.getHeaders().clear();
  200.             }
  201.             else if(onlyLogFileTraceBody) {
  202.                 if(messaggio.getBody()!=null) {
  203.                     messaggio.getBody().unlock();
  204.                     messaggio.getBody().clearResources();
  205.                     messaggio.setBody(null);
  206.                 }
  207.                 messaggio.setContentType(null);
  208.             }
  209.         }
  210.         
  211.         if(messaggiDaEliminare!=null) {
  212.             while(!messaggiDaEliminare.isEmpty()) {
  213.                 TipoMessaggio tipo = messaggiDaEliminare.remove(0);
  214.                 if(transaction.sizeMessaggi()>0) {
  215.                     for (int i = 0; i < transaction.sizeMessaggi(); i++) {
  216.                         if(tipo.equals(transaction.getMessaggio(i).getTipoMessaggio())) {
  217.                             if(transaction.getMessaggio(i).getBody()!=null){
  218.                                 transaction.getMessaggio(i).getBody().unlock();
  219.                                 transaction.getMessaggio(i).getBody().clearResources();
  220.                                 transaction.getMessaggio(i).setBody(null);
  221.                             }
  222.                             transaction.removeMessaggio(i);
  223.                             break;
  224.                         }
  225.                     }
  226.                 }
  227.             }
  228.         }

  230.     }
  231.     
  232.     public void invoke(TipoPdD tipoPdD, Context context, RequestInfo requestInfo, Busta busta, FaseTracciamento faseTracciamento) throws UtilsException {
  233.         this.invoke(tipoPdD, context, requestInfo, busta, faseTracciamento, null);
  234.     }
  235.     public void invoke(TipoPdD tipoPdD, Context context, RequestInfo requestInfo, Busta busta, FaseTracciamento faseTracciamento, Map<String, String> outputMap) throws UtilsException {
  236.         List<String> topic = null;
  237.         Map<String, Topic> topicMap = null;
  238.         switch (tipoPdD) {
  239.         case DELEGATA:
  240.             topic = this.config.getTopicFruizioni();
  241.             topicMap = this.config.getTopicFruizioneMap();
  242.             break;
  243.         case APPLICATIVA:
  244.             topic = this.config.getTopicErogazioni();
  245.             topicMap = this.config.getTopicErogazioniMap();
  246.             break;
  247.         default:
  248.             break;
  249.         }
  250.         if(topic!=null && !topic.isEmpty()) {
  251.             
  252.             boolean requestSent = isRequestSent(context);
  253.             
  254.             List<Topic> topicInvoke = new ArrayList<>();
  255.             for (String topicName : topic) {
  256.                 Topic topicConfig = topicMap.get(topicName);
  257.                 if(add(topicConfig, faseTracciamento, requestSent)) {
  258.                     topicInvoke.add(topicConfig);
  259.                 }
  260.                 /**else {
  261.                     System.out.println("SKIP["+topicName+"] in fase ["+faseTracciamento+"]");
  262.                 }*/
  263.             }
  264.             
  265.             invoke(topicInvoke, 
  266.                     requestInfo, context, busta,
  267.                     outputMap);
  268.         }
  269.     }
  270.     
  271.     private boolean isRequestSent(Context context) {
  272.         boolean requestSent = false;
  273.         if(context!=null && context.containsKey(Costanti.RICHIESTA_INOLTRATA_BACKEND)) {
  274.             Object o = context.getObject(Costanti.RICHIESTA_INOLTRATA_BACKEND);
  275.             if(o instanceof String) {
  276.                 String s = (String) o;
  277.                 if(Costanti.RICHIESTA_INOLTRATA_BACKEND_VALORE.equals(s)) {
  278.                     requestSent = true;
  279.                 }
  280.             }
  281.         }
  282.         return requestSent;
  283.     }
  284.     
  285.     private boolean add(Topic topicConfig, FaseTracciamento faseTracciamento, boolean requestSent) {
  286.         if(!topicConfig.isEnabled(faseTracciamento)) {
  287.             /**System.out.println("R1");*/
  288.             return false;
  289.         }
  290.         
  291.         if(topicConfig.isOnlyRequestSent() &&
  292.             !requestSent) {
  293.             /**System.out.println("R1");*/
  294.             return false;
  295.         }
  296.         if(topicConfig.isOnlyInRequestContentDefined()) {
  297.             boolean contentDefined = this.t.getInRequestSize()>0;
  298.             if(!contentDefined) {
  299.                 /**System.out.println("R3");*/
  300.                 return false;
  301.             }
  302.         }
  303.         if(topicConfig.isOnlyOutRequestContentDefined()) {
  304.             boolean contentDefined = this.t.getOutRequestSize()>0;
  305.             if(!contentDefined) {
  306.                 /**System.out.println("R4");*/
  307.                 return false;
  308.             }
  309.         }
  310.         if(topicConfig.isOnlyInResponseContentDefined()) {
  311.             boolean contentDefined = this.t.getInResponseSize()>0;
  312.             if(!contentDefined) {
  313.                 /**System.out.println("R5");*/
  314.                 return false;
  315.             }
  316.         }
  317.         if(topicConfig.isOnlyOutResponseContentDefined()) {
  318.             boolean contentDefined = this.t.getOutResponseSize()>0;
  319.             if(!contentDefined) {
  320.                 /**System.out.println("R6");*/
  321.                 return false;
  322.             }
  323.         }
  324.         
  325.         return true;
  326.     }
  327.     
  328.     private void invoke(List<Topic> topicInvoke, 
  329.             RequestInfo requestInfo, Context context, Busta busta,
  330.             Map<String, String> outputMap) throws UtilsException {
  331.         if(topicInvoke!=null && !topicInvoke.isEmpty()) {
  332.             
  333.             this.resolveProperties(requestInfo, context, busta);
  334.             
  335.             for (Topic topicConfig : topicInvoke) {
  336.                 String value = this.resolve(topicConfig.getFormat());
  337.                 if(outputMap!=null) {
  338.                     outputMap.put(topicConfig.getNome(), value);
  339.                 }
  340.                 else {
  341.                     switch (this.config.getLogSeverity()) {
  342.                     case trace:
  343.                         topicConfig.getLog().trace(value);      
  344.                         break;
  345.                     case debug:
  346.                         topicConfig.getLog().debug(value);      
  347.                         break;
  348.                     case info:
  349.                         topicConfig.getLog().info(value);       
  350.                         break;
  351.                     case warn:
  352.                         topicConfig.getLog().warn(value);       
  353.                         break;
  354.                     case error:
  355.                         topicConfig.getLog().error(value);      
  356.                         break;
  357.                     }
  358.                 }
  359.             }
  360.         }
  361.     }
  362.         
  363.     private void resolveProperties(RequestInfo requestInfo, Context context, Busta busta) throws UtilsException {
  364.         
  365.         Map<String, String> propertiesEncryptionModes = this.config.getPropertiesEncryptionMode();
  366.         FileTraceEncrypt encrypt = null;
  367.         if(!propertiesEncryptionModes.isEmpty()) {
  368.             encrypt = new FileTraceEncrypt(this.log, requestInfo, context, busta);
  369.         }
  370.         
  371.         List<String> properties = this.config.getPropertiesSortKeys();
  372.         if(properties!=null && !properties.isEmpty()) {
  373.             for (String sortKey : properties) {
  374.                 String pName = this.config.getPropertiesNames().get(sortKey);
  375.                 String pValue = this.config.getPropertiesValues().get(sortKey);
  376.                 /**System.out.println("SORT ["+sortKey+"] ["+pName+"]");*/
  377.                 String resolvedValue = this.resolve(pValue);
  378.                 
  379.                 String mode = propertiesEncryptionModes.get(sortKey);
  380.                 if(encrypt!=null && mode!=null && StringUtils.isNotEmpty(mode)) {
  381.                     FileTraceEncryptConfig encryptionConfig = this.config.getEncryptionMode().get(mode);
  382.                     resolvedValue = encrypt.encrypt(encryptionConfig, resolvedValue);
  383.                 }
  384.                 
  385.                 this.t.addProperty(pName, resolvedValue);
  386.                 this.tBase64.addProperty(pName, resolvedValue);
  387.             }
  388.         }
  389.     }
  390.     
  391.     private String resolve(String format) throws UtilsException {
  392.         boolean complexField = false;
  393.         return DynamicStringReplace.replace(format, this.dynamicMap, true, complexField);
  394.     }
  395. }
Created with JaCoCo 0.8.8.202204050719