DumpUtilities.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.utils.service.context.dump;


  24. import java.util.List;
  25. import java.util.Map;

  27. import org.apache.cxf.interceptor.Fault;
  28. import org.openspcoop2.utils.LoggerWrapperFactory;
  29. import org.openspcoop2.utils.logger.beans.Property;
  30. import org.openspcoop2.utils.logger.beans.context.application.ApplicationTransaction;
  31. import org.openspcoop2.utils.logger.beans.context.batch.BatchTransaction;
  32. import org.openspcoop2.utils.logger.beans.context.core.AbstractTransaction;
  33. import org.openspcoop2.utils.logger.beans.context.core.AbstractTransactionWithClient;
  34. import org.openspcoop2.utils.logger.beans.context.core.BaseServer;
  35. import org.openspcoop2.utils.logger.beans.context.core.ConnectionMessage;
  36. import org.openspcoop2.utils.logger.beans.context.core.HttpClient;
  37. import org.openspcoop2.utils.logger.beans.context.core.HttpServer;
  38. import org.openspcoop2.utils.logger.beans.context.core.Request;
  39. import org.openspcoop2.utils.logger.beans.context.core.Response;
  40. import org.openspcoop2.utils.logger.beans.context.proxy.ProxyTransaction;
  41. import org.openspcoop2.utils.logger.constants.MessageType;
  42. import org.openspcoop2.utils.service.context.ContextThreadLocal;
  43. import org.openspcoop2.utils.service.context.IContext;
  44. import org.openspcoop2.utils.service.context.server.ServerConfig;

  46. /**
  47.  * DumpUtilities
  48.  * 
  49.  * @author Andrea Poli (apoli@link.it)
  50.  * @author $Author$
  51.  * @version $Rev$, $Date$
  52.  */
  53. public class DumpUtilities {
  54.     
  55.     private ServerConfig serverConfig;
  56.     private DumpConfig dumpConfig;

  58.     public DumpUtilities(DumpConfig dumpConfig) {
  59.         this.dumpConfig = dumpConfig;
  60.     }
  61.     public DumpUtilities(ServerConfig serverConfig) {
  62.         this.serverConfig = serverConfig;
  63.         this.dumpConfig = serverConfig.getDumpConfig();
  64.     }

  66.     
  67.     public void processBeforeSend(DumpRequest request) throws Fault {
  68.         
  69.         try {
  70.             
  71.             //
  72.             // Realizzo la stessa logica di MessageLoggingHandlerUtils
  73.             //
  74.             IContext ctx = ContextThreadLocal.get();
  75.     
  76.             AbstractTransaction transaction = ctx.getApplicationContext().getTransaction();
  77.             
  78.             AbstractTransactionWithClient transactionWithClient = null;
  79.             if(transaction instanceof AbstractTransactionWithClient) {
  80.                 transactionWithClient = (AbstractTransactionWithClient) transaction;
  81.             }
  82.             
  83.             org.openspcoop2.utils.logger.beans.Message msg = new org.openspcoop2.utils.logger.beans.Message();
  84.             if(request.getPayload()!=null) {
  85.                 msg.setContent(request.getPayload());
  86.             }
  87.             msg.setContentType(request.getContentType());
  88.             if(this.serverConfig!=null) {
  89.                 msg.setIdOperation(this.serverConfig.getOperationId());
  90.                 msg.setIdServer(this.serverConfig.getServerId());
  91.             }
  92.             msg.setIdTransaction(ctx.getTransactionId());
  93.             switch (this.dumpConfig.getRole()) {
  94.             case SERVER:
  95.                 msg.setType(MessageType.REQUEST_IN);
  96.                 
  97.                 if(transactionWithClient!=null) {
  98.                     if(transactionWithClient.getRequest()==null) {
  99.                         transactionWithClient.setRequest(new Request());
  100.                     }
  101.                     if(msg.getContent()!=null ) {
  102.                         transactionWithClient.getRequest().setSize(Long.valueOf(msg.getContent().length));
  103.                     }
  104.                     else {
  105.                         transactionWithClient.getRequest().setSize(0l);
  106.                     }
  107.                 }
  108.                 
  109.                 break;
  110.             case CLIENT:
  111.                 msg.setType(MessageType.REQUEST_OUT);
  112.                 
  113.                 if(this.serverConfig!=null) {
  114.                     
  115.                     if(this.serverConfig.getOperationId()==null) {
  116.                         throw new Exception("ServerConfig.operationId undefined");
  117.                     }
  118.                         
  119.                     List<BaseServer> list = null;
  120.                     BaseServer server = null;
  121.                     if(transaction instanceof ApplicationTransaction) {
  122.                         list = ((ApplicationTransaction)transaction).getServers();
  123.                     }
  124.                     else if(transaction instanceof BatchTransaction) {
  125.                         list = ((BatchTransaction)transaction).getServers();
  126.                     }
  127.                     else if(transaction instanceof ProxyTransaction) {
  128.                         server = ((ProxyTransaction)transaction).getServer();
  129.                     }
  130.                     if(list!=null && list.size()>0) {
  131.                         for (BaseServer baseServer : list) {
  132.                             if(this.serverConfig.getOperationId().equals(baseServer.getIdOperation())) {
  133.                                 server = baseServer;
  134.                                 break;
  135.                             }
  136.                         }
  137.                     }
  138.                     
  139.                     if(server==null) {
  140.                         throw new Exception("Server '"+this.serverConfig.getOperationId()+"' not found");
  141.                     }
  142.                     
  143.                     if(server.getRequest()==null) {
  144.                         server.setRequest(new ConnectionMessage());
  145.                     }
  146.                     if(msg.getContent()!=null ) {
  147.                         server.getRequest().setSize(Long.valueOf(msg.getContent().length));
  148.                     }
  149.                     else {
  150.                         server.getRequest().setSize(0l);
  151.                     }
  152.                 }
  153.                 
  154.                 break;
  155.             }
  156.             
  157.             Map<String, String> headers = request.getHeaders();
  158.             for (Map.Entry<String, String> entry : headers.entrySet())
  159.             {
  160.                 String key = entry.getKey();
  161.                 String value = entry.getValue();
  162.                 msg.addHeader(new Property(key, value));
  163.             }
  164.         
  165.             ctx.getApplicationLogger().log(msg);
  166.             
  167.         } catch (Throwable e) {
  168.             LoggerWrapperFactory.getLogger(DumpInInterceptor.class).error(e.getMessage(),e);
  169.             throw new Fault(e); 
  170.         }
  171.         
  172.     }
  173.     
  174.     public void processAfterSend(DumpResponse response) throws Fault {
  175.         
  176.         try {
  177.             
  178.             // sender.send(event);
  179.             IContext ctx = ContextThreadLocal.get();

  181.             AbstractTransaction transaction = ctx.getApplicationContext().getTransaction();
  182.             
  183.             AbstractTransactionWithClient transactionWithClient = null;
  184.             if(transaction instanceof AbstractTransactionWithClient) {
  185.                 transactionWithClient = (AbstractTransactionWithClient) transaction;
  186.             }
  187.             
  188.             org.openspcoop2.utils.logger.beans.Message msg = new org.openspcoop2.utils.logger.beans.Message();
  189.             if(response.getPayload()!=null) {
  190.                 msg.setContent(response.getPayload());
  191.             }
  192.             msg.setContentType(response.getContentType());
  193.             if(this.serverConfig!=null) {
  194.                 msg.setIdOperation(this.serverConfig.getOperationId());
  195.                 msg.setIdServer(this.serverConfig.getServerId());
  196.             }
  197.             msg.setIdTransaction(ctx.getTransactionId());
  198.             switch (this.dumpConfig.getRole()) {
  199.             case SERVER:
  200.                 msg.setType(MessageType.RESPONSE_OUT);
  201.                 
  202.                 if(transactionWithClient!=null) {
  203.                     if(transactionWithClient.getResponse()==null) {
  204.                         transactionWithClient.setResponse(new Response());
  205.                     }
  206.                     if(msg.getContent()!=null ) {
  207.                         transactionWithClient.getResponse().setSize(Long.valueOf(msg.getContent().length));
  208.                     }
  209.                     else {
  210.                         transactionWithClient.getResponse().setSize(0l);
  211.                     }
  212.                 }
  213.                 
  214.                 if(transactionWithClient!=null && transactionWithClient.getClient() instanceof HttpClient) {
  215.                     try {
  216.                         if(response.getResponseCode()!=null) {
  217.                             ((HttpClient)transactionWithClient.getClient()).setResponseStatusCode(response.getResponseCode());
  218.                         }
  219.                     }catch(Throwable t) {
  220.                     }
  221.                 }
  222.                 
  223.                 break;
  224.             case CLIENT:
  225.                 msg.setType(MessageType.RESPONSE_IN);
  226.                 
  227.                 if(this.serverConfig!=null) {
  228.                     
  229.                     if(this.serverConfig.getOperationId()==null) {
  230.                         throw new Exception("ServerConfig.operationId undefined");
  231.                     }
  232.                         
  233.                     List<BaseServer> list = null;
  234.                     BaseServer server = null;
  235.                     if(transaction instanceof ApplicationTransaction) {
  236.                         list = ((ApplicationTransaction)transaction).getServers();
  237.                     }
  238.                     else if(transaction instanceof BatchTransaction) {
  239.                         list = ((BatchTransaction)transaction).getServers();
  240.                     }
  241.                     else if(transaction instanceof ProxyTransaction) {
  242.                         server = ((ProxyTransaction)transaction).getServer();
  243.                     }
  244.                     if(list!=null && list.size()>0) {
  245.                         for (BaseServer baseServer : list) {
  246.                             if(this.serverConfig.getOperationId().equals(baseServer.getIdOperation())) {
  247.                                 server = baseServer;
  248.                                 break;
  249.                             }
  250.                         }
  251.                     }
  252.                     
  253.                     if(server==null) {
  254.                         throw new Exception("Server '"+this.serverConfig.getOperationId()+"' not found");
  255.                     }
  256.                     
  257.                     if(server.getResponse()==null) {
  258.                         server.setResponse(new ConnectionMessage());
  259.                     }
  260.                     if(msg.getContent()!=null ) {
  261.                         server.getResponse().setSize(Long.valueOf(msg.getContent().length));
  262.                     }
  263.                     else {
  264.                         server.getResponse().setSize(0l);
  265.                     }
  266.                     
  267.                     if(server instanceof HttpServer) {
  268.                         try {
  269.                             if(response.getResponseCode()!=null) {
  270.                                 ((HttpServer)server).setResponseStatusCode(response.getResponseCode());
  271.                             }
  272.                         }catch(Throwable t) {
  273.                         }
  274.                     }
  275.                 }
  276.                 
  277.                 break;
  278.             }
  279.             
  280.             Map<String, String> headers = response.getHeaders();
  281.             for (Map.Entry<String, String> entry : headers.entrySet())
  282.             {
  283.                 String key = entry.getKey();
  284.                 String value = entry.getValue();
  285.                 msg.addHeader(new Property(key, value));
  286.             }
  287.         
  288.             ctx.getApplicationLogger().log(msg);
  289.                             
  290.         } catch (Throwable e) {
  291.             LoggerWrapperFactory.getLogger(DumpInInterceptor.class).error(e.getMessage(),e);
  292.             throw new Fault(e); 
  293.         }
  294.         
  295.     }
  296.     
  297. }
Created with JaCoCo 0.8.8.202204050719