InRequestProtocolHandlerGestioneControlloTraffico.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.core.controllo_traffico.handler;

  22. import java.security.SecureRandom;
  23. import java.util.ArrayList;
  24. import java.util.HashMap;
  25. import java.util.Iterator;
  26. import java.util.List;
  27. import java.util.Map;
  28. import java.util.Properties;

  30. import org.openspcoop2.core.commons.CoreException;
  31. import org.openspcoop2.core.config.PortaApplicativa;
  32. import org.openspcoop2.core.config.PortaDelegata;
  33. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  34. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  35. import org.openspcoop2.core.controllo_traffico.ConfigurazioneGenerale;
  36. import org.openspcoop2.core.controllo_traffico.ConfigurazionePolicy;
  37. import org.openspcoop2.core.controllo_traffico.ElencoIdPolicyAttive;
  38. import org.openspcoop2.core.controllo_traffico.IdActivePolicy;
  39. import org.openspcoop2.core.controllo_traffico.beans.DatiTransazione;
  40. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  41. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  42. import org.openspcoop2.core.controllo_traffico.constants.Costanti;
  43. import org.openspcoop2.core.controllo_traffico.constants.TipoErrore;
  44. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  45. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsaPolicyAttiva;
  46. import org.openspcoop2.core.controllo_traffico.driver.IGestorePolicyAttive;
  47. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  48. import org.openspcoop2.core.eventi.constants.CodiceEventoControlloTraffico;
  49. import org.openspcoop2.core.eventi.constants.TipoEvento;
  50. import org.openspcoop2.message.constants.ServiceBinding;
  51. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  52. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  53. import org.openspcoop2.pdd.core.PdDContext;
  54. import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
  55. import org.openspcoop2.pdd.core.controllo_traffico.ConnettoreUtilities;
  56. import org.openspcoop2.pdd.core.controllo_traffico.CostantiControlloTraffico;
  57. import org.openspcoop2.pdd.core.controllo_traffico.DatiTempiRisposta;
  58. import org.openspcoop2.pdd.core.controllo_traffico.GeneratoreMessaggiDiagnostici;
  59. import org.openspcoop2.pdd.core.controllo_traffico.GeneratoreMessaggiErrore;
  60. import org.openspcoop2.pdd.core.controllo_traffico.GestoreControlloTraffico;
  61. import org.openspcoop2.pdd.core.controllo_traffico.RisultatoVerificaPolicy;
  62. import org.openspcoop2.pdd.core.controllo_traffico.StatoTraffico;
  63. import org.openspcoop2.pdd.core.controllo_traffico.policy.InterceptorPolicyUtilities;
  64. import org.openspcoop2.pdd.core.controllo_traffico.policy.PolicyFiltroApplicativoUtilities;
  65. import org.openspcoop2.pdd.core.controllo_traffico.policy.PolicyVerifier;
  66. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  67. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.GestorePolicyAttive;
  68. import org.openspcoop2.pdd.core.handlers.HandlerException;
  69. import org.openspcoop2.pdd.core.handlers.InRequestProtocolContext;
  70. import org.openspcoop2.pdd.core.transazioni.Transaction;
  71. import org.openspcoop2.pdd.core.transazioni.TransactionDeletedException;
  72. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  73. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  74. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  75. import org.openspcoop2.protocol.sdk.constants.EsitoTransazioneName;
  76. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  77. import org.openspcoop2.protocol.utils.EsitiProperties;
  78. import org.openspcoop2.utils.Utilities;
  79. import org.slf4j.Logger;

  81. /**     
  82.  * InRequestProtocolHandlerGestioneControlloTraffico
  83.  *
  84.  * @author Poli Andrea (poli@link.it)
  85.  * @author $Author$
  86.  * @version $Rev$, $Date$
  87.  */
  88. public class InRequestProtocolHandlerGestioneControlloTraffico {

  90.     private static java.util.Random rndEngine = null;
  91.     private static synchronized void initRandom() {
  92.         if(rndEngine==null) {
  93.             rndEngine = new SecureRandom();
  94.         }
  95.     }
  96.     public static java.util.Random getRandom() {
  97.         if(rndEngine==null) {
  98.             initRandom();
  99.         }
  100.         return rndEngine;
  101.     }
  102.     
  103.     public void process(InRequestProtocolContext context, Transaction tr) throws HandlerException{
  104.         
  105.         Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> mapPolicyAttive = null;
  106.         boolean mapFromRequestInfo = false;
  107.         
  108.         DatiTransazione datiTransazione = null;
  109.                 
  110.         IGestorePolicyAttive gestorePolicyGlobale = null;
  111.         IGestorePolicyAttive gestorePolicyPorta = null;
  112.         PolicyConfiguration policyConfigurationGlobale = null;
  113.         PolicyConfiguration policyConfigurationPorta = null;
  114.         PolicyConfiguration policyConfigurationHeaderHttp = null;
  115.         
  116.         GestoreControlloTraffico gestoreControlloTraffico = null;
  117.         ConfigurazionePdDManager configPdDManager = null;
  118.         
  119.         TipoErrore tipoErrore = TipoErrore.FAULT;
  120.         boolean includiDescrizioneErrore = true;
  121.         
  122.         ConfigurazioneGatewayControlloTraffico configurazioneControlloTraffico = null;
  123.         
  124.         Logger log = null;
  125.         
  126.         ServiceBinding serviceBinding = ServiceBinding.REST;
  127.         
  128.         RequestInfo requestInfo = null;
  129.         if(context!=null && context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)){
  130.             requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  131.         }
  132.         
  133.         boolean registerThread = true;
  134.         OpenSPCoop2Properties op2Properties = null;
  135.         try{
  136.             
  137.             // ConfigurazioneControlloTraffico
  138.             op2Properties = OpenSPCoop2Properties.getInstance();
  139.             configurazioneControlloTraffico =  op2Properties.getConfigurazioneControlloTraffico();
  140.             
  141.             // Logger
  142.             log = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(op2Properties.isControlloTrafficoDebug());
  143.             
  144.             if(context==null) {
  145.                 throw new CoreException("InRequestProtocolContext is null");
  146.             }
  147.             
  148.             // Leggo i dati del servizio
  149.             datiTransazione = InterceptorPolicyUtilities.readDatiTransazione(context);
  150.             registerThread = InterceptorPolicyUtilities.checkRegisterThread(datiTransazione);
  151.             // Se registerThread == false, sicuramente la richiesta non verra' veicolata fuori e terminerà con un errore all'interno della PdD.

  153.             if(context!=null && context.getMessaggio()!=null && context.getMessaggio().getServiceBinding()!=null) {
  154.                 serviceBinding = context.getMessaggio().getServiceBinding();
  155.             }
  156.             
  157.             if(registerThread){             
  158.                 
  159.                 configPdDManager = ConfigurazionePdDManager.getInstance(context.getStato());
  160.                                 
  161.                 // Prelevo la configurazione del Controllo del Traffico per quanto concerne le policy attive
  162.                 
  163.                 if(requestInfo!=null && requestInfo.getRequestRateLimitingConfig()!=null) {
  164.                     if(requestInfo.getRequestRateLimitingConfig().getNomePorta()==null && datiTransazione!=null) {
  165.                         requestInfo.getRequestRateLimitingConfig().setDatiPorta(context.getTipoPorta(), datiTransazione.getNomePorta(), 
  166.                                 datiTransazione.getIdServizio(),
  167.                                 datiTransazione.getSoggettoFruitore());
  168.                     }
  169.                     if(requestInfo.getRequestRateLimitingConfig().getMapPolicyAttive()!=null) {
  170.                         mapPolicyAttive = requestInfo.getRequestRateLimitingConfig().getMapPolicyAttive();
  171.                         mapFromRequestInfo = true;
  172.                     }
  173.                 }
  174.                 
  175.                 if(!mapFromRequestInfo) {
  176.                 
  177.                     mapPolicyAttive = new HashMap<>();
  178.                     
  179.                     Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> mapPolicyAttiveAPI = null;
  180.                     try {
  181.                         mapPolicyAttiveAPI = configPdDManager.getElencoIdPolicyAttiveAPI(configurazioneControlloTraffico.isPolicyReadedWithDynamicCache(),
  182.                                 context.getTipoPorta(), datiTransazione.getNomePorta());
  183.                     }catch(DriverConfigurazioneNotFound notFound) {
  184.                         // ignore
  185.                     }
  186.                     if(mapPolicyAttiveAPI!=null && !mapPolicyAttiveAPI.isEmpty()) {
  187.                         Iterator<TipoRisorsaPolicyAttiva> it = mapPolicyAttiveAPI.keySet().iterator();
  188.                         while (it.hasNext()) {
  189.                             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = it.next();
  190.                             ElencoIdPolicyAttive elencoPolicyAttiveAPI = mapPolicyAttiveAPI.get(tipoRisorsaPolicyAttiva);
  191.                             if(elencoPolicyAttiveAPI!=null) {
  192.                                 ElencoIdPolicyAttive cloned = (ElencoIdPolicyAttive) elencoPolicyAttiveAPI.clone(); // altrimenti dopo aggiungendo quelle globali si modifica l'oggetto in cache
  193.                                 mapPolicyAttive.put(tipoRisorsaPolicyAttiva, cloned);
  194.                             }
  195.                         }
  196.                     }
  197.     
  198.                     Map<TipoRisorsaPolicyAttiva, ElencoIdPolicyAttive> mapPolicyAttiveGlobali = null;
  199.                     try {
  200.                         mapPolicyAttiveGlobali = configPdDManager.getElencoIdPolicyAttiveGlobali(configurazioneControlloTraffico.isPolicyReadedWithDynamicCache());
  201.                     }catch(DriverConfigurazioneNotFound notFound) {
  202.                         // ignore
  203.                     }
  204.                     if(mapPolicyAttiveGlobali!=null && !mapPolicyAttiveGlobali.isEmpty()) {
  205.                         Iterator<TipoRisorsaPolicyAttiva> it = mapPolicyAttiveGlobali.keySet().iterator();
  206.                         while (it.hasNext()) {
  207.                             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = it.next();
  208.                             ElencoIdPolicyAttive elencoPolicyAttiveGlobali = mapPolicyAttiveGlobali.get(tipoRisorsaPolicyAttiva);
  209.                             
  210.                             if(mapPolicyAttive.containsKey(tipoRisorsaPolicyAttiva)) {
  211.                                 ElencoIdPolicyAttive elencoPolicyAttiveCloned = mapPolicyAttive.get(tipoRisorsaPolicyAttiva); // gia' clonato per l'api sopra
  212.                                 for (IdActivePolicy idActivePolicyGlobale : elencoPolicyAttiveGlobali.getIdActivePolicyList()) {
  213.                                     elencoPolicyAttiveCloned.addIdActivePolicy(idActivePolicyGlobale);
  214.                                 }
  215.                             }
  216.                             else {
  217.                                 ElencoIdPolicyAttive cloned = (ElencoIdPolicyAttive) elencoPolicyAttiveGlobali.clone(); // per non modificare l'oggetto in cache
  218.                                 mapPolicyAttive.put(tipoRisorsaPolicyAttiva, cloned);
  219.                             }
  220.                         }
  221.                     }
  222.                     
  223.                     if(requestInfo!=null && requestInfo.getRequestRateLimitingConfig()!=null) {
  224.                         requestInfo.getRequestRateLimitingConfig().setMapPolicyAttive(mapPolicyAttive);
  225.                     }
  226.                 
  227.                 }

  229.                 
  230.                 // ** ConfigurazionePolicy per gestore **
  231.                 
  232.                 policyConfigurationGlobale = configPdDManager.getConfigurazionePolicyRateLimitingGlobali(requestInfo);
  233.                 context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_POLICY_CONFIG_GLOBALE, policyConfigurationGlobale);
  234.                                 
  235.                 PolicyConfiguration policyConfigurationApiInternal = null;
  236.                 if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPD()!=null){
  237.                     PortaDelegata pd = configPdDManager.getPortaDelegata(context.getIntegrazione().getIdPD(),requestInfo);
  238.                     policyConfigurationApiInternal = new PolicyConfiguration(pd.getProprietaRateLimitingList());
  239.                 }
  240.                 else if(context.getIntegrazione()!=null && context.getIntegrazione().getIdPA()!=null){
  241.                     PortaApplicativa pa = configPdDManager.getPortaApplicativa(context.getIntegrazione().getIdPA(),requestInfo);
  242.                     policyConfigurationApiInternal = new PolicyConfiguration(pa.getProprietaRateLimitingList());
  243.                 }
  244.                 if(policyConfigurationApiInternal==null) {
  245.                     throw new CoreException("Policy configuration not found");
  246.                 }
  247.                 else {
  248.                     if(policyConfigurationApiInternal.isGestionePolicyRidefinita()) {
  249.                         policyConfigurationPorta = policyConfigurationApiInternal;
  250.                     }
  251.                     else {
  252.                         policyConfigurationPorta = policyConfigurationGlobale;
  253.                     }
  254.                 }
  255.                 context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_POLICY_CONFIG_PORTA, policyConfigurationPorta);
  256.                 
  257.                 // ** ConfigurazionePolicy per header http **
  258.                 if(policyConfigurationApiInternal.isGestioneHttpHeadersRidefinita()) {
  259.                     policyConfigurationHeaderHttp = policyConfigurationApiInternal;
  260.                 }
  261.                 else {
  262.                     policyConfigurationHeaderHttp = policyConfigurationGlobale;
  263.                 }
  264.                 
  265.                 // Gestore delle Policy
  266.                 gestorePolicyPorta = GestorePolicyAttive.getInstance(policyConfigurationPorta.getType());
  267.                 gestorePolicyGlobale = GestorePolicyAttive.getInstance(policyConfigurationGlobale.getType());
  268.                 
  269.                 // Gestore del Traffico
  270.                 gestoreControlloTraffico = GestoreControlloTraffico.getInstance();
  271.                 
  272.                 // Configurazione Generale del RateLimiting
  273.                 ConfigurazioneGenerale configurazioneGenerale = configPdDManager.getConfigurazioneControlloTraffico(requestInfo);       
  274.                 if(configurazioneGenerale.getRateLimiting()!=null){
  275.                     if(configurazioneGenerale.getRateLimiting().getTipoErrore()!=null) {
  276.                         TipoErrore tipoErrorTmp = TipoErrore.toEnumConstant(configurazioneGenerale.getRateLimiting().getTipoErrore());
  277.                         if(tipoErrorTmp!=null) {
  278.                             tipoErrore = tipoErrorTmp;
  279.                         }
  280.                     }
  281.                     includiDescrizioneErrore = configurazioneGenerale.getRateLimiting().isTipoErroreIncludiDescrizione();
  282.                 }
  283.                 
  284.             }
  285.             
  286.             /**System.out.println("PROCESS registerThread["+registerThread+"] datiControlloTraffico["+(datiControlloTraffico!=null)+"]");*/
  287.             
  288.         }catch(Exception e){
  289.             throw new HandlerException("Configurazione non disponibile: "+e.getMessage(), e);
  290.         }
  291.         
  292.         if(registerThread){ 

  294.             
  295.             try{
  296.                 

  298.                 MsgDiagnostico msgDiag = this.buildMsgDiagnostico(context);
  299.                 
  300.                 // Verifico se la Pdd è congestionata ed emetto l'opportuno diagnostico
  301.                 boolean pddCongestionata = 
  302.                         isCondizioneCongestionamentoPortaDominio(context, gestoreControlloTraffico, msgDiag, tr);
  303.                 
  304.                 
  305.                 // Effettuo controllo di rate limiting
  306.                 if(mapPolicyAttive!=null && !mapPolicyAttive.isEmpty()){
  307.                                     
  308.                     // Emetto Diagnostico  Controllo di RateLimiting
  309.                     msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_CONTROLLO_IN_CORSO);
  310.                     
  311.                     int policyTotali = 0;
  312.                     int policyDisabilitate = 0;
  313.                     int policyFiltrate = 0;
  314.                     int policyNonApplicabili = 0;
  315.                     int policyRispettate = 0;
  316.                     int policyViolate = 0;
  317.                     int policyViolateWarningOnly = 0;
  318.                     int policyInErrore = 0;
  319.                     
  320.                     List<RisultatoVerificaPolicy> policyBloccanti = new ArrayList<>();
  321.                     
  322.                     List<String> pddContextUniqueIdsPolicy = new ArrayList<>();
  323.                     List<IDUnivocoGroupByPolicy> pddContextIdUnivociGroupBy = new ArrayList<>();
  324.                     List<Boolean> pddContextPolicyApplicabile = new ArrayList<>();
  325.                     List<Boolean> pddContextPolicyViolata = new ArrayList<>();
  326.                     List<String> pddContextApi = new ArrayList<>();
  327.                     
  328.                     DatiTempiRisposta datiTempiRisposta = null;
  329.                     
  330.                     // NOTA: Questo blocco che gestisce la raccolta delle policy soddisfatte e violate per generare gli opportuni header potrebbe essere riscritto utilizzando TipoRisorsaPolicyAttiva
  331.                     // Per adesso non viene modificato.
  332.                     List<RisultatoVerificaPolicy> risultatiVerificaPolicyViolate = new ArrayList<>();
  333.                     Map<TipoRisorsa,List<RisultatoVerificaPolicy>> risultatiVerificaPolicyRispettate = new HashMap<>();
  334.                     for (TipoRisorsa tipoRisorsa : TipoRisorsa.values()) {
  335.                         risultatiVerificaPolicyRispettate.put(tipoRisorsa, new ArrayList<>());
  336.                     }
  337.                     
  338.                     try{
  339.                         
  340.                         Iterator<TipoRisorsaPolicyAttiva> it = mapPolicyAttive.keySet().iterator();
  341.                         while (it.hasNext()) {
  342.                             TipoRisorsaPolicyAttiva tipoRisorsaPolicyAttiva = it.next();
  343.                             ElencoIdPolicyAttive elencoPolicyAttivePerRisorsa = mapPolicyAttive.get(tipoRisorsaPolicyAttiva);
  344.                         
  345.                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_RISORSA, tipoRisorsaPolicyAttiva.getValue());
  346.                             
  347.                             boolean policyRispettataCheRichiedeBreak = false;
  348.                             boolean policyViolataBreak = false;
  349.                             
  350.                             for (IdActivePolicy idActive : elencoPolicyAttivePerRisorsa.getIdActivePolicyList()) {
  351.                                 
  352.                                 policyTotali++;
  353.                                 
  354.                                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_ID, idActive.getNome());
  355.                                                         
  356.                                 try{
  357.                                 
  358.                                     if(idActive.isEnabled()){
  359.                                     
  360.                                         // Prelevo la configurazione del Controllo del Traffico per quanto concerne le policy attive
  361.                                         AttivazionePolicy attivazionePolicy = null;
  362.                                         try {
  363.                                             String id = UniqueIdentifierUtilities.getUniqueId(idActive);
  364.                                             if(mapFromRequestInfo) {
  365.                                                 attivazionePolicy = requestInfo.getRequestRateLimitingConfig().getAttivazionePolicy(id);
  366.                                             }
  367.                                             if(attivazionePolicy==null) {
  368.                                                 attivazionePolicy = configPdDManager.getAttivazionePolicy(configurazioneControlloTraffico.isPolicyReadedWithDynamicCache(), id);
  369.                                                 if(requestInfo!=null && requestInfo.getRequestRateLimitingConfig()!=null) {
  370.                                                     requestInfo.getRequestRateLimitingConfig().addAttivazionePolicy(id, attivazionePolicy);
  371.                                                 }
  372.                                             }
  373.                                         }catch(DriverConfigurazioneNotFound notFound) {
  374.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_ALIAS, idActive.getNome());
  375.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_TIPO, "");
  376.                                             throw new CoreException("Istanza di Policy con id ["+idActive.getNome()+"] non esistente: "+notFound.getMessage(),notFound);
  377.                                         }
  378.                                         if(attivazionePolicy==null){
  379.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_ALIAS, idActive.getNome());
  380.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_TIPO, "");
  381.                                             throw new CoreException("Istanza di Policy con id ["+idActive.getNome()+"] non esistente?");
  382.                                         }
  383.                                         
  384.                                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_ALIAS,
  385.                                                 PolicyUtilities.getNomeActivePolicy(attivazionePolicy.getAlias(), attivazionePolicy.getIdActivePolicy()));
  386.                                         if(attivazionePolicy.getFiltro()!=null && attivazionePolicy.getFiltro().getNomePorta()!=null && !"".equals(attivazionePolicy.getFiltro().getNomePorta())) {
  387.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_TIPO, Costanti.POLICY_API);
  388.                                         }
  389.                                         else {
  390.                                             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_TIPO, Costanti.POLICY_GLOBALE);
  391.                                         }
  392.                                         
  393.                                         
  394.                                         // Verifico se un eventuale filtro configurato per la policy matcha con i dati della transazione
  395.                                         boolean matchFiltro = !policyRispettataCheRichiedeBreak && !policyViolataBreak && InterceptorPolicyUtilities.filter(attivazionePolicy.getFiltro(), datiTransazione, context.getStato(), requestInfo);
  396.                                         if(matchFiltro){
  397.                                             
  398.                                             if(attivazionePolicy.getFiltro().isEnabled() && attivazionePolicy.getFiltro().isInformazioneApplicativaEnabled()){
  399.                                             
  400.                                                 // Verifico Filtro Applicativo
  401.                                                 String valorePresente = PolicyFiltroApplicativoUtilities.getValore(log,
  402.                                                         attivazionePolicy.getFiltro().getInformazioneApplicativaTipo(), 
  403.                                                         attivazionePolicy.getFiltro().getInformazioneApplicativaNome(), 
  404.                                                         context, datiTransazione, true);
  405.                                                 if(valorePresente==null || valorePresente.equals(attivazionePolicy.getFiltro().getInformazioneApplicativaValore())==false){
  406.                                                     
  407.                                                     policyFiltrate++;
  408.                                                     
  409.                                                     // Emetto Diagnostico Policy Filtrata
  410.                                                     if(valorePresente==null){
  411.                                                         valorePresente = "n.d.";
  412.                                                     }
  413.                                                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO, "Filtro Applicativo atteso ["+
  414.                                                             attivazionePolicy.getFiltro().getInformazioneApplicativaValore()+"] differente da quello estratto dalla transazione ["+
  415.                                                             valorePresente+"]");
  416.                                                     GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  417.                                                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_FILTRATA, log);
  418.                                                     
  419.                                                     matchFiltro = false;
  420.                                                     
  421.                                                 }
  422.                                                 
  423.                                             }
  424.                                             
  425.                                             if(matchFiltro){
  426.                                                     
  427.                                                 // Prelevo la configurazione del Controllo del Traffico per quanto concerne le policy istanziata
  428.                                                 ConfigurazionePolicy configurazionePolicy = null;
  429.                                                 try {
  430.                                                     String id = idActive.getIdPolicy();
  431.                                                     if(mapFromRequestInfo) {
  432.                                                         configurazionePolicy = requestInfo.getRequestRateLimitingConfig().getConfigurazionePolicy(id);
  433.                                                     }
  434.                                                     if(configurazionePolicy==null) {
  435.                                                         configurazionePolicy = configPdDManager.getConfigurazionePolicy(configurazioneControlloTraffico.isPolicyReadedWithDynamicCache(), id);
  436.                                                         if(requestInfo!=null && requestInfo.getRequestRateLimitingConfig()!=null) {
  437.                                                             requestInfo.getRequestRateLimitingConfig().addConfigurazionePolicy(id, configurazionePolicy);
  438.                                                         }
  439.                                                     }
  440.                                                 }catch(DriverConfigurazioneNotFound notFound) {
  441.                                                     throw new CoreException("Policy con id ["+idActive.getIdPolicy()+"] non esistente: "+notFound.getMessage(),notFound);
  442.                                                 }
  443.                                                 if(configurazionePolicy==null){
  444.                                                     throw new CoreException("Policy con id ["+idActive.getIdPolicy()+"] non esistente?");
  445.                                                 }
  446.                                                 
  447.                                                 org.openspcoop2.core.controllo_traffico.beans.ActivePolicy activePolicy = 
  448.                                                         new org.openspcoop2.core.controllo_traffico.beans.ActivePolicy();
  449.                                                 activePolicy.setInstanceConfiguration(attivazionePolicy);
  450.                                                 activePolicy.setConfigurazionePolicy(configurazionePolicy);
  451.                                                 activePolicy.setTipoRisorsaPolicy(TipoRisorsa.toEnumConstant(configurazionePolicy.getRisorsa(), true));
  452.                                                 activePolicy.setConfigurazioneControlloTraffico(configurazioneControlloTraffico);
  453.                                                 
  454.                                                 
  455.                                                 // Creo Gruppo
  456.                                                 IDUnivocoGroupByPolicy idUnivocoGroupBy = InterceptorPolicyUtilities.convertToID(log,
  457.                                                         datiTransazione, attivazionePolicy.getGroupBy(), context);
  458.                                                 pddContextIdUnivociGroupBy.add(idUnivocoGroupBy);
  459.                                                 pddContextUniqueIdsPolicy.add(UniqueIdentifierUtilities.getUniqueId(attivazionePolicy));
  460.                                                 
  461.                                                 // Se la Policy richiede una condizione di applicabilità per degrado prestazionale
  462.                                                 // e non ho ancora recuperato l'informazione sui tempi lo faccio adesso
  463.                                                 if(datiTempiRisposta==null){
  464.                                                     datiTempiRisposta = ConnettoreUtilities.getDatiTempiRisposta(context, datiTransazione, requestInfo);
  465.                                                 }
  466.                                                                                             
  467.                                                 // Verifico rispetto ai dati collezionati
  468.                                                 
  469.                                                 IGestorePolicyAttive gestorePolicy = null;
  470.                                                 PolicyConfiguration policyConfiguration = null;
  471.                                                 if(attivazionePolicy.getFiltro()!=null && attivazionePolicy.getFiltro().getNomePorta()!=null && !"".equals(attivazionePolicy.getFiltro().getNomePorta())) {
  472.                                                     gestorePolicy = gestorePolicyPorta;
  473.                                                     policyConfiguration = policyConfigurationPorta;
  474.                                                     TipoRisorsaPolicyAttiva tipoRisorsaPolicy = TipoRisorsaPolicyAttiva.getTipo(activePolicy.getTipoRisorsaPolicy(), configurazionePolicy.isSimultanee());
  475.                                                     if(!gestorePolicy.getType().isSupportedResource(tipoRisorsaPolicy)) {
  476.                                                         // caso in cui viene configurata una policy su una specifica erogazione/fruizione, senza che nella porta stessa venga ridefinito un gestore specifico, e a livello di configurazione globale viene poi impostato un gestore non compatibile
  477.                                                         log.error("Riscontrata policy '"+attivazionePolicy.getIdActivePolicy()+"' (alias:"+attivazionePolicy.getAlias()+") non compatibile con il tipo di gestore '"+gestorePolicy.getType()+"'; verrà utilizzato il gestore di default");
  478.                                                         policyConfiguration = new PolicyConfiguration(true);
  479.                                                         gestorePolicy = GestorePolicyAttive.getInstance(policyConfiguration.getType());
  480.                                                         pddContextApi.add(CostantiControlloTraffico.PDD_CONTEXT_LIST_API_OR_GLOBAL_OR_DEFAULT_VALUE_DEFAULT);
  481.                                                     }
  482.                                                     else {
  483.                                                         pddContextApi.add(CostantiControlloTraffico.PDD_CONTEXT_LIST_API_OR_GLOBAL_OR_DEFAULT_VALUE_API);
  484.                                                     }
  485.                                                 }
  486.                                                 else {
  487.                                                     gestorePolicy = gestorePolicyGlobale;
  488.                                                     policyConfiguration = policyConfigurationGlobale;
  489.                                                     pddContextApi.add(CostantiControlloTraffico.PDD_CONTEXT_LIST_API_OR_GLOBAL_OR_DEFAULT_VALUE_GLOBAL);
  490.                                                 }
  491.                                                 
  492.                                                 RisultatoVerificaPolicy risultatoVerifica = PolicyVerifier.verifica(
  493.                                                         configPdDManager, context.getProtocolFactory(),
  494.                                                         gestorePolicy, policyConfiguration, log,
  495.                                                         activePolicy,
  496.                                                         idUnivocoGroupBy, context.getPddContext(), 
  497.                                                         msgDiag, tr, datiTransazione, pddCongestionata, datiTempiRisposta,
  498.                                                         pddContextPolicyApplicabile, pddContextPolicyViolata,
  499.                                                         context.getStato());
  500.                                                 
  501.                                                 // Gestisco Risultato Verifica
  502.                                                 if(risultatoVerifica.isErroreGenerico()){
  503.                                                     
  504.                                                     policyInErrore++;
  505.                                                     
  506.                                                     // Emetto Diagnostico Policy in Errore
  507.                                                     log.error("Errore durante il controllo della policy con id["+idActive.getNome()+"]: "+risultatoVerifica.getDescrizione());
  508.                                                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VIOLATA_MOTIVO, risultatoVerifica.getDescrizione());
  509.                                                     GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  510.                                                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_IN_ERRORE, log);
  511.                                                     
  512.                                                     // Aggiungo tra le policy bloccanti
  513.                                                     policyBloccanti.add(risultatoVerifica);
  514.                                                     
  515.                                                 }
  516.                                                 else if(risultatoVerifica.isNonApplicabile()){
  517.                                                     
  518.                                                     policyNonApplicabili++;
  519.                                                     
  520.                                                     // Emetto Diagnostico Policy  Non Applicabile
  521.                                                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_NON_APPLICABILE_MOTIVO, risultatoVerifica.getDescrizione());
  522.                                                     GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  523.                                                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_NON_APPLICABILE, log);
  524.                                                     
  525.                                                 }
  526.                                                 else if(risultatoVerifica.isViolata()){
  527.                                                 
  528.                                                     risultatiVerificaPolicyViolate.add(risultatoVerifica);
  529.                                                     
  530.                                                     if(risultatoVerifica.isWarningOnly()){
  531.         
  532.                                                         policyViolateWarningOnly++;
  533.                                                         
  534.                                                         // Emetto Diagnostico Policy Violata in Warning Only
  535.                                                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VIOLATA_MOTIVO, risultatoVerifica.getDescrizione());
  536.                                                         GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  537.                                                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_VIOLATA_WARNING_ONLY, log);
  538.                                                         
  539.                                                     }
  540.                                                     else{
  541.                                                     
  542.                                                         policyViolate++;
  543.                                                         
  544.                                                         // Emetto Diagnostico Policy Violata
  545.                                                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VIOLATA_MOTIVO, risultatoVerifica.getDescrizione());
  546.                                                         GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  547.                                                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_VIOLATA, log);
  548.                                                         
  549.                                                         // Aggiungo tra le policy bloccanti
  550.                                                         policyBloccanti.add(risultatoVerifica);
  551.                                                         
  552.                                                     }
  553.                                                     
  554.                                                     policyViolataBreak = true;
  555.                                                 }
  556.                                                 else{
  557.                                                     
  558.                                                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_ACTIVE_CONTINUE, attivazionePolicy.isContinuaValutazione()+"");
  559.                                                                                                         
  560.                                                     risultatiVerificaPolicyRispettate.get(risultatoVerifica.getRisorsa()).add(risultatoVerifica);
  561.                                                     
  562.                                                     // Emetto Diagnostico Policy Rispettata
  563.                                                     GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  564.                                                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_RISPETTATA, log);
  565.                                                     
  566.                                                     policyRispettate++;
  567.                                                     
  568.                                                     if(!attivazionePolicy.isContinuaValutazione()) {
  569.                                                         policyRispettataCheRichiedeBreak = true;
  570.                                                     }
  571.                                                     
  572.                                                 }
  573.                                                 
  574.                                             }
  575.                                             
  576.                                         }
  577.                                         else{
  578.                                             
  579.                                             policyFiltrate++;
  580.                                             
  581.                                             // Emetto Diagnostico Policy Filtrata
  582.                                             if(policyRispettataCheRichiedeBreak) {
  583.                                                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO, 
  584.                                                         GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO_BREAK);
  585.                                             }
  586.                                             else if(policyViolataBreak) {
  587.                                                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO, 
  588.                                                         GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO_BREAK_VIOLATA);
  589.                                             }
  590.                                             else {
  591.                                                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO, 
  592.                                                         GeneratoreMessaggiErrore.TEMPLATE_POLICY_FILTRATA_MOTIVO_FILTRO+ PolicyUtilities.toStringFilter(attivazionePolicy.getFiltro()));
  593.                                             }
  594.                                             GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  595.                                                     GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_FILTRATA, log);
  596.                                             
  597.                                         }
  598.                                         
  599.                                     }
  600.                                     else{
  601.                                         
  602.                                         policyDisabilitate++;
  603.                                         
  604.                                         // Emetto Diagnostico Policy Disabilitata
  605.                                         GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  606.                                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_DISABILITATA, log);
  607.                                         
  608.                                     }
  609.                                     
  610.                                 }
  611.                                 catch(Throwable e){
  612.                                     
  613.                                     policyInErrore++;
  614.                                     
  615.                                     // Messaggio di Errore
  616.                                     Throwable tConMessaggio = Utilities.getInnerNotEmptyMessageException(e);
  617.                                     String eMessaggio = tConMessaggio.getMessage();
  618.                                     if(eMessaggio==null || "".equals(eMessaggio) || "null".equalsIgnoreCase(eMessaggio)){
  619.                                         eMessaggio = "Internal Error"; // molto probabilmente si tratta di un null Pointer. Lo si vedra' nel logger
  620.                                     }
  621.                                     
  622.                                     // Emetto Diagnostico Policy in Errore
  623.                                     log.error("Errore durante il controllo della policy con id["+idActive.getNome()+"]: "+eMessaggio,e);
  624.                                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VIOLATA_MOTIVO, eMessaggio);
  625.                                     GeneratoreMessaggiDiagnostici.emitDiagnostic(msgDiag, 
  626.                                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_IN_ERRORE, log);
  627.                                     
  628.                                     // Aggiungo tra le policy bloccanti
  629.                                     RisultatoVerificaPolicy policyError = new RisultatoVerificaPolicy();
  630.                                     policyError.setErroreGenerico(true);
  631.                                     policyError.setDescrizione(eMessaggio);
  632.                                     policyBloccanti.add(policyError);
  633.                                     
  634.                                 }
  635.                                 
  636.                                 // Effettuo clean dei dati dinamici della policy
  637.                                 GeneratoreMessaggiDiagnostici.cleanPolicyValues(msgDiag);
  638.                                 
  639.                                 
  640.                             } // -- fine for delle policy di una risorsa
  641.                             
  642.                         } // -- fine iterazione per tipo di risorsa
  643.                         
  644.                     }finally{
  645.                         if(!pddContextIdUnivociGroupBy.isEmpty()){
  646.                             context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_LIST_GROUP_BY_CONDITION, pddContextIdUnivociGroupBy);
  647.                             context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_LIST_UNIQUE_ID_POLICY,pddContextUniqueIdsPolicy);
  648.                             context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_LIST_POLICY_APPLICABILE,pddContextPolicyApplicabile);
  649.                             context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_LIST_POLICY_VIOLATA,pddContextPolicyViolata);
  650.                             context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_LIST_API_OR_GLOBAL_OR_DEFAULT,pddContextApi);
  651.                         }
  652.                     }

  654.                     // Gestione header HTTP da aggiungere alla transazione
  655.                     
  656.                     Properties headerTrasportoRateLimiting = new Properties();
  657.                     if(!risultatiVerificaPolicyViolate.isEmpty()) {
  658.                         // calcolo tempo maggiore
  659.                         long ms = -1;
  660.                         Map<TipoRisorsa,List<RisultatoVerificaPolicy>> risultatiVerificaPolicyViolateMap = new HashMap<>();
  661.                         for (RisultatoVerificaPolicy risultatoVerificaPolicy : risultatiVerificaPolicyViolate) {
  662.                             
  663.                             List<RisultatoVerificaPolicy> l = null;
  664.                             if(risultatiVerificaPolicyViolateMap.containsKey(risultatoVerificaPolicy.getRisorsa())) {
  665.                                 l = risultatiVerificaPolicyViolateMap.get(risultatoVerificaPolicy.getRisorsa());
  666.                             }
  667.                             else {
  668.                                 l = new ArrayList<>();
  669.                                 risultatiVerificaPolicyViolateMap.put(risultatoVerificaPolicy.getRisorsa(), l);
  670.                             }
  671.                             l.add(risultatoVerificaPolicy);
  672.                             
  673.                             if(risultatoVerificaPolicy.getMsBeforeResetCounters()!=null) {
  674.                                 long tmp = risultatoVerificaPolicy.getMsBeforeResetCounters().longValue();
  675.                                 if(tmp>ms) {
  676.                                     ms = tmp;
  677.                                 }
  678.                             }
  679.                         }
  680.                         if(ms>0) {
  681.                             // trasformo in secondi
  682.                             long sec = -1;
  683.                             if(ms>1000) {
  684.                                 // trasformo in secondi
  685.                                 sec = ms / 1000;
  686.                             }
  687.                             else if(ms>0) {
  688.                                 // genero comunque l'header approssimando l'intervallo al secondo + backoff
  689.                                 sec=1;
  690.                             }

  692.                             if(!policyConfigurationHeaderHttp.isDisabledHttpHeaders_retryAfter()) {
  693.                             
  694.                                 // aggiungo backoff
  695.                                 if(!policyConfigurationHeaderHttp.isForceDisabledHttpHeaders_retryAfter_backoff()) {
  696.                                     if(policyConfigurationHeaderHttp.getForceHttpHeaders_retryAfter_backoff()>0) {
  697.                                         sec = sec + getRandom().nextInt(policyConfigurationHeaderHttp.getForceHttpHeaders_retryAfter_backoff());
  698.                                     }
  699.                                     else {
  700.                                         if(op2Properties.getControlloTrafficoRetryAfterHeaderRandomBackoff()!=null && op2Properties.getControlloTrafficoRetryAfterHeaderRandomBackoff()>0) {
  701.                                             sec = sec + getRandom().nextInt(op2Properties.getControlloTrafficoRetryAfterHeaderRandomBackoff());
  702.                                         }
  703.                                     }
  704.                                 }
  705.                                 String [] headers = op2Properties.getControlloTrafficoRetryAfterHeader();
  706.                                 if(headers!=null && headers.length>0) {
  707.                                     for (String header : headers) {
  708.                                         headerTrasportoRateLimiting.put(header, sec+"");
  709.                                     }
  710.                                 }
  711.                             }
  712.                         }
  713.                         if(risultatiVerificaPolicyViolateMap.size()>0) {
  714.                             // produco anche i normali header
  715.                             gestioneHeaderRateLimit(risultatiVerificaPolicyViolateMap, headerTrasportoRateLimiting, op2Properties, policyConfigurationHeaderHttp);
  716.                         }
  717.                     }
  718.                     else if(risultatiVerificaPolicyRispettate.size()>0) {
  719.                         gestioneHeaderRateLimit(risultatiVerificaPolicyRispettate, headerTrasportoRateLimiting, op2Properties, policyConfigurationHeaderHttp);
  720.                     }
  721.                         
  722.                     //Aggiungo nel pddContext e poi li recupero nei servizi
  723.                     if(headerTrasportoRateLimiting.size()>0) {
  724.                         context.getPddContext().addObject(CostantiControlloTraffico.PDD_CONTEXT_HEADER_RATE_LIMITING,headerTrasportoRateLimiting);
  725.                     }
  726.                     
  727.                     
  728.                     // Emetto Diagnostico Terminazione Controllo Rate limiting
  729.                     
  730.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY, policyTotali+"");
  731.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY, policyTotali);
  732.                                         
  733.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_DISABILITATE, policyDisabilitate+"");
  734.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_DISABILITATE, policyDisabilitate);
  735.                     
  736.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_FILTRATE, policyFiltrate+"");
  737.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_FILTRATE, policyFiltrate);
  738.                     
  739.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_NON_APPLICATE, policyNonApplicabili+"");
  740.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_NON_APPLICATE, policyNonApplicabili);
  741.                     
  742.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_RISPETTATE, policyRispettate+"");
  743.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_RISPETTATE, policyRispettate);
  744.                     
  745.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_VIOLATE, policyViolate+"");
  746.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_VIOLATE, policyViolate);
  747.                     
  748.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_VIOLATE_WARNING_ONLY, policyViolateWarningOnly+"");
  749.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_VIOLATE_WARNING_ONLY, policyViolateWarningOnly);
  750.                     
  751.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_NUMERO_POLICY_IN_ERRORE, policyInErrore+"");
  752.                     context.getPddContext().addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_NUMERO_POLICY_IN_ERRORE, policyInErrore);
  753.                     
  754.                     if(policyViolate>0 || policyInErrore>0){
  755.                         msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_CONTROLLO_TERMINATO_CON_ERRORE);
  756.                         
  757.                         if(policyInErrore>0) {
  758.                             EsitoTransazioneName esito = op2Properties.getControlloTrafficoEsitiPolicyElaborazioneInErrore(EsitiProperties.getInstance(log, context.getProtocolFactory()));
  759.                             if(EsitoTransazioneName.CONTROLLO_TRAFFICO_POLICY_VIOLATA.equals(esito)) {
  760.                                 GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoPolicyViolated(context.getPddContext(), false);
  761.                             }
  762.                             else {
  763.                                 GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoPolicyInError(context.getPddContext(), esito);
  764.                             }
  765.                         }
  766.                         else {
  767.                             GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoPolicyViolated(context.getPddContext(), false);
  768.                         }
  769.                         
  770.                         HandlerException he = GeneratoreMessaggiErrore.getControlloTrafficoPolicyViolated(policyBloccanti,
  771.                                 configurazioneControlloTraffico.isErroreGenerico(), context.getPddContext());
  772.                         he.setEmettiDiagnostico(false);
  773.                         GeneratoreMessaggiErrore.configureHandlerExceptionByTipoErrore(serviceBinding, he, tipoErrore, includiDescrizioneErrore,log);
  774.                         throw he;
  775.                     }
  776.                     else if(policyViolateWarningOnly>0){
  777.                         
  778.                         GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoPolicyViolated(context.getPddContext(), true);
  779.                         
  780.                         msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_CONTROLLO_TERMINATO_CON_SUCCESSO);
  781.                         
  782.                     }
  783.                     else{
  784.                         msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_POLICY_CONTROLLO_TERMINATO_CON_SUCCESSO);
  785.                     }
  786.                 }
  787.                     
  788.             }
  789.             catch(HandlerException e){
  790.                 throw e;
  791.             }
  792.             catch(Exception e){
  793.                     
  794.                 GeneratoreMessaggiErrore.addPddContextInfoControlloTrafficoGenericError(context.getPddContext());
  795.                 
  796.                 throw GeneratoreMessaggiErrore.getErroreProcessamento(e, context.getPddContext());

  798.             }
  799.             
  800.         }

  802.     }
  803.     
  804.     private void gestioneHeaderRateLimit(Map<TipoRisorsa,List<RisultatoVerificaPolicy>> risultatiVerificaPolicy, Properties headerTrasportoRateLimiting,
  805.             OpenSPCoop2Properties op2Properties,
  806.             PolicyConfiguration policyConfigurationPorta) {
  807.         
  808.         if(policyConfigurationPorta.isDisabledHttpHeaders()) {
  809.             return;
  810.         }
  811.         
  812.         for (TipoRisorsa tipoRisorsa : risultatiVerificaPolicy.keySet()) {

  814.             List<RisultatoVerificaPolicy> risultato = risultatiVerificaPolicy.get(tipoRisorsa);
  815.             // in presenza di piu' policy dello stesso tipo considero la policy che termina più lontano nel tempo: NO Sbagliato poiche' se una ha un numero minore non va bene.
  816.             // Prendo a questo punto quella con il minore limite.
  817.             
  818.             RisultatoVerificaPolicy risultatoUtilizzato = null;
  819.             RisultatoVerificaPolicy risultatoUtilizzatoSimultanee = null;
  820.             List<RisultatoVerificaPolicy> altrePolicy = new ArrayList<>();
  821.             List<RisultatoVerificaPolicy> altrePolicySimultanee = new ArrayList<>();
  822.             
  823.             for (RisultatoVerificaPolicy risultatoVerificaPolicy : risultato) {
  824.                 if(TipoRisorsa.NUMERO_RICHIESTE.equals(tipoRisorsa) && risultatoVerificaPolicy.isSimultanee()) {
  825.                     if(risultatoUtilizzatoSimultanee==null) {
  826.                         risultatoUtilizzatoSimultanee = risultatoVerificaPolicy;
  827.                     }
  828.                     else {
  829.                         long numeroRimasti = -1;
  830.                         if(risultatoUtilizzatoSimultanee.getMaxValue()!=null) {
  831.                             numeroRimasti = risultatoUtilizzatoSimultanee.getMaxValue().longValue();
  832.                         }
  833.                         long numeroCheck = -1;
  834.                         if(risultatoVerificaPolicy.getMaxValue()!=null) {
  835.                             numeroCheck = risultatoVerificaPolicy.getMaxValue().longValue();
  836.                         }
  837.                         boolean switchPolicy = false;
  838.                         if(numeroCheck>0) {
  839.                             if(numeroRimasti>0) {
  840.                                 if(numeroCheck<numeroRimasti) {
  841.                                     altrePolicySimultanee.add(risultatoUtilizzatoSimultanee);
  842.                                     risultatoUtilizzatoSimultanee = risultatoVerificaPolicy;
  843.                                     switchPolicy = true;
  844.                                 }
  845.                             }
  846.                             else {
  847.                                 altrePolicySimultanee.add(risultatoUtilizzatoSimultanee);
  848.                                 risultatoUtilizzatoSimultanee = risultatoVerificaPolicy;
  849.                                 switchPolicy = true;
  850.                             }
  851.                         }
  852.                         if(!switchPolicy) {
  853.                             altrePolicySimultanee.add(risultatoVerificaPolicy);
  854.                         }
  855.                     }
  856.                 }
  857.                 else {
  858.                     if(risultatoUtilizzato==null) {
  859.                         risultatoUtilizzato = risultatoVerificaPolicy;
  860.                     }
  861.                     else {
  862.                         long numeroRimasti = -1;
  863.                         if(risultatoUtilizzato.getMaxValue()!=null) {
  864.                             numeroRimasti = risultatoUtilizzato.getMaxValue().longValue();
  865.                         }
  866.                         long numeroCheck = -1;
  867.                         if(risultatoVerificaPolicy.getMaxValue()!=null) {
  868.                             numeroCheck = risultatoVerificaPolicy.getMaxValue().longValue();
  869.                         }
  870.                         boolean switchPolicy = false;
  871.                         if(numeroCheck>0) {
  872.                             if(numeroRimasti>0) {
  873.                                 if(numeroCheck<numeroRimasti) {
  874.                                     altrePolicy.add(risultatoUtilizzato);
  875.                                     risultatoUtilizzato = risultatoVerificaPolicy;
  876.                                     switchPolicy = true;
  877.                                 }
  878.                             }
  879.                             else {
  880.                                 altrePolicy.add(risultatoUtilizzato);
  881.                                 risultatoUtilizzato = risultatoVerificaPolicy;
  882.                                 switchPolicy = true;
  883.                             }
  884.                         }
  885.                         if(!switchPolicy) {
  886.                             altrePolicy.add(risultatoVerificaPolicy);
  887.                         }
  888.                     }
  889.                 }
  890.             }
  891.             
  892.             if(!policyConfigurationPorta.isDisabledHttpHeaders_limit() && risultatoUtilizzatoSimultanee!=null &&
  893.                 risultatoUtilizzatoSimultanee.getMaxValue()!=null) {
  894.                 try {
  895.                     String [] headers = op2Properties.getControlloTrafficoNumeroRichiesteSimultaneeHeaderLimit();
  896.                     if(headers!=null && headers.length>0) {
  897.                         for (String header : headers) {
  898.                             headerTrasportoRateLimiting.put(header, risultatoUtilizzatoSimultanee.getMaxValue().longValue()+"");
  899.                         }
  900.                     }
  901.                 }catch(Exception e) { 
  902.                     // errore non dovrebbe succedere
  903.                 }
  904.                 
  905.                 if(risultatoUtilizzatoSimultanee.getActualValue()!=null) {
  906.                     long rimanenti = risultatoUtilizzatoSimultanee.getMaxValue().longValue() - risultatoUtilizzatoSimultanee.getActualValue().longValue();
  907.                     if(rimanenti<0) {  // gli attuali conteggia anche quelle bloccate
  908.                         rimanenti = 0;
  909.                     }
  910.                     try {
  911.                         String [] headers = op2Properties.getControlloTrafficoNumeroRichiesteSimultaneeHeaderRemaining();
  912.                         if(headers!=null && headers.length>0) {
  913.                             for (String header : headers) {
  914.                                 headerTrasportoRateLimiting.put(header, rimanenti+"");
  915.                             }
  916.                         }
  917.                     }catch(Exception e) { 
  918.                         // errore non dovrebbe succedere
  919.                     }
  920.                 }
  921.             }
  922.             
  923.             if(risultatoUtilizzato!=null &&
  924.                 risultatoUtilizzato.getMaxValue()!=null) {
  925.                     
  926.                 if(!policyConfigurationPorta.isDisabledHttpHeaders_limit()) {
  927.                     try {
  928.                         String [] headers = null;
  929.                         boolean windows = false;
  930.                         switch (tipoRisorsa) {
  931.                         case DIMENSIONE_MASSIMA_MESSAGGIO:
  932.                             // non viene usata
  933.                             break;
  934.                         case NUMERO_RICHIESTE:
  935.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteHeaderLimit();
  936.                             windows = op2Properties.getControlloTrafficoNumeroRichiesteHeaderLimitWindows();
  937.                             break;
  938.                         case OCCUPAZIONE_BANDA:
  939.                             headers = op2Properties.getControlloTrafficoOccupazioneBandaHeaderLimit();
  940.                             windows = op2Properties.getControlloTrafficoOccupazioneBandaHeaderLimitWindows();
  941.                             break;
  942.                         case TEMPO_MEDIO_RISPOSTA:
  943.                             headers = op2Properties.getControlloTrafficoTempoMedioRispostaHeaderLimit();
  944.                             windows = op2Properties.getControlloTrafficoTempoMedioRispostaHeaderLimitWindows();
  945.                             break;
  946.                         case TEMPO_COMPLESSIVO_RISPOSTA:
  947.                             headers = op2Properties.getControlloTrafficoTempoComplessivoRispostaHeaderLimit();
  948.                             windows = op2Properties.getControlloTrafficoTempoComplessivoRispostaHeaderLimitWindows();
  949.                             break;
  950.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  951.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimit();
  952.                             windows = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderLimitWindows();
  953.                             break;
  954.                         case NUMERO_RICHIESTE_FALLITE:
  955.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteHeaderLimit();
  956.                             windows = op2Properties.getControlloTrafficoNumeroRichiesteFalliteHeaderLimitWindows();
  957.                             break;
  958.                         case NUMERO_FAULT_APPLICATIVI:
  959.                             headers = op2Properties.getControlloTrafficoNumeroFaultApplicativiHeaderLimit();
  960.                             windows = op2Properties.getControlloTrafficoNumeroFaultApplicativiHeaderLimitWindows();
  961.                             break;
  962.                         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  963.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimit();
  964.                             windows = op2Properties.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderLimitWindows();
  965.                             break;
  966.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  967.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimit();
  968.                             windows = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderLimitWindows();
  969.                             break;
  970.                         }
  971.                         
  972.                         if(policyConfigurationPorta.isForceHttpHeaders_limit_no_windows()) {
  973.                             windows = false;
  974.                         }
  975.                         else if(policyConfigurationPorta.isForceHttpHeaders_limit_windows()) {
  976.                             windows = true;
  977.                         }
  978.                         
  979.                         if(headers!=null && headers.length>0) {
  980.                             
  981.                             Long maxValue = risultatoUtilizzato.getMaxValueBeforeNormalizing()!=null ? risultatoUtilizzato.getMaxValueBeforeNormalizing() : risultatoUtilizzato.getMaxValue();
  982.                             
  983.                             StringBuilder sb = new StringBuilder("");
  984.                             if(windows && risultatoUtilizzato.getMsWindow()!=null && maxValue!=null) {
  985.                                 long ms = risultatoUtilizzato.getMsWindow();
  986.                                 long sec = -1;
  987.                                 if(ms>1000) {
  988.                                     // trasformo in secondi
  989.                                     sec = ms / 1000;
  990.                                 }
  991.                                 if(sec>0) {
  992.                                     sb.append(", ").append(maxValue.longValue()).append(";w=").append(sec);
  993.                                 }
  994.                                 if(!altrePolicy.isEmpty()) {
  995.                                     for (RisultatoVerificaPolicy r : altrePolicy) {
  996.                                         
  997.                                         Long maxValueR = r.getMaxValueBeforeNormalizing()!=null ? r.getMaxValueBeforeNormalizing() : r.getMaxValue();
  998.                                         
  999.                                         if(r.getMsWindow()!=null && maxValueR!=null) {
  1000.                                             ms = r.getMsWindow();
  1001.                                             sec = -1;
  1002.                                             if(ms>1000) {
  1003.                                                 // trasformo in secondi
  1004.                                                 sec = ms / 1000;
  1005.                                             }
  1006.                                             if(sec>0) {
  1007.                                                 sb.append(", ").append(maxValueR.longValue()).append(";w=").append(sec);
  1008.                                             }
  1009.                                         }
  1010.                                     }
  1011.                                 }
  1012.                             }
  1013.                             
  1014.                             for (String header : headers) {
  1015.                                 headerTrasportoRateLimiting.put(header, maxValue.longValue()+""+sb.toString());
  1016.                             }
  1017.                         }
  1018.                     }catch(Exception e) { 
  1019.                         // errore non dovrebbe succedere
  1020.                     }
  1021.                 }
  1022.                 
  1023.                 if(!policyConfigurationPorta.isDisabledHttpHeaders_remaining() && risultatoUtilizzato.getActualValue()!=null) {
  1024.                     long rimanenti = risultatoUtilizzato.getMaxValue().longValue() - risultatoUtilizzato.getActualValue().longValue();
  1025.                     if(rimanenti<0) {  // gli attuali conteggia anche quelle bloccate
  1026.                         rimanenti = 0;
  1027.                     }
  1028.                     if(rimanenti==0 && !risultatoUtilizzato.isViolata() && !risultatoUtilizzato.isRemainingZeroValue()) {
  1029.                         rimanenti = 1; // gestione cluster
  1030.                     }
  1031.                     try {
  1032.                         String [] headers = null;
  1033.                         switch (tipoRisorsa) {
  1034.                         case DIMENSIONE_MASSIMA_MESSAGGIO:
  1035.                             // non viene usata
  1036.                             break;
  1037.                         case NUMERO_RICHIESTE:
  1038.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteHeaderRemaining();
  1039.                             break;
  1040.                         case OCCUPAZIONE_BANDA:
  1041.                             headers = op2Properties.getControlloTrafficoOccupazioneBandaHeaderRemaining();
  1042.                             break;
  1043.                         case TEMPO_MEDIO_RISPOSTA:
  1044.                             // non ha senso
  1045.                             /**headers = op2Properties.getControlloTrafficoTempoMedioRispostaHeaderRemaining();*/
  1046.                             break;
  1047.                         case TEMPO_COMPLESSIVO_RISPOSTA:
  1048.                             headers = op2Properties.getControlloTrafficoTempoComplessivoRispostaHeaderRemaining();
  1049.                             break;
  1050.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  1051.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderRemaining();
  1052.                             break;
  1053.                         case NUMERO_RICHIESTE_FALLITE:
  1054.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteHeaderRemaining();
  1055.                             break;
  1056.                         case NUMERO_FAULT_APPLICATIVI:
  1057.                             headers = op2Properties.getControlloTrafficoNumeroFaultApplicativiHeaderRemaining();
  1058.                             break;
  1059.                         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  1060.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderRemaining();
  1061.                             break;
  1062.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  1063.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderRemaining();
  1064.                             break;
  1065.                         }
  1066.                         if(headers!=null && headers.length>0) {
  1067.                             for (String header : headers) {
  1068.                                 headerTrasportoRateLimiting.put(header, rimanenti+"");
  1069.                             }
  1070.                         }
  1071.                     }catch(Exception e) { 
  1072.                         // errore non dovrebbe succedere
  1073.                     }
  1074.                 }
  1075.             }
  1076.             if(!policyConfigurationPorta.isDisabledHttpHeaders_reset() && risultatoUtilizzato!=null && risultatoUtilizzato.getMsBeforeResetCounters()!=null) {
  1077.                 
  1078.                 long ms = risultatoUtilizzato.getMsBeforeResetCounters().longValue();
  1079.                 long sec = -1;
  1080.                 if(ms>1000) {
  1081.                     // trasformo in secondi
  1082.                     sec = ms / 1000;
  1083.                 }
  1084.                 else if(ms>0) {
  1085.                     // genero comunque l'header approssimando l'intervallo al secondo
  1086.                     sec=1;
  1087.                 }
  1088.                 
  1089.                 if(sec>0) {
  1090.                     try {
  1091.                         String [] headers = null;
  1092.                         switch (tipoRisorsa) {
  1093.                         case DIMENSIONE_MASSIMA_MESSAGGIO:
  1094.                             // non viene usata
  1095.                             break;
  1096.                         case NUMERO_RICHIESTE:
  1097.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteHeaderReset();
  1098.                             break;
  1099.                         case OCCUPAZIONE_BANDA:
  1100.                             headers = op2Properties.getControlloTrafficoOccupazioneBandaHeaderReset();
  1101.                             break;
  1102.                         case TEMPO_MEDIO_RISPOSTA:
  1103.                             headers = op2Properties.getControlloTrafficoTempoMedioRispostaHeaderReset();
  1104.                             break;
  1105.                         case TEMPO_COMPLESSIVO_RISPOSTA:
  1106.                             headers = op2Properties.getControlloTrafficoTempoComplessivoRispostaHeaderReset();
  1107.                             break;
  1108.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  1109.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoHeaderReset();
  1110.                             break;
  1111.                         case NUMERO_RICHIESTE_FALLITE:
  1112.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteHeaderReset();
  1113.                             break;
  1114.                         case NUMERO_FAULT_APPLICATIVI:
  1115.                             headers = op2Properties.getControlloTrafficoNumeroFaultApplicativiHeaderReset();
  1116.                             break;
  1117.                         case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  1118.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteFalliteOFaultApplicativiHeaderReset();
  1119.                             break;
  1120.                         case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  1121.                             headers = op2Properties.getControlloTrafficoNumeroRichiesteCompletateConSuccessoOFaultApplicativiHeaderReset();
  1122.                             break;
  1123.                         }
  1124.                         
  1125.                         if(headers!=null && headers.length>0) {
  1126.                             for (String header : headers) {
  1127.                                 headerTrasportoRateLimiting.put(header, sec+"");
  1128.                             }
  1129.                         }
  1130.                     }catch(Exception e) { 
  1131.                         // errore non dovrebbe succedere
  1132.                     }
  1133.                 }
  1134.             }
  1135.         }
  1136.         
  1137.     }

  1139.     
  1140.     private boolean isCondizioneCongestionamentoPortaDominio(InRequestProtocolContext context, 
  1141.             GestoreControlloTraffico gestoreControlloCongestione,
  1142.             MsgDiagnostico msgDiag, Transaction tr) throws TransactionDeletedException{
  1143.         
  1144.         if(context==null) {
  1145.             throw new TransactionDeletedException("Context is null");
  1146.         }
  1147.         
  1148.         PdDContext pddContext = context.getPddContext();
  1149.         
  1150.         boolean isPddCongestionataInformazioneIdentificataDalThread = false;
  1151.         Object oPddCongestionataThread = pddContext.getObject(CostantiControlloTraffico.PDD_CONTEXT_PDD_CONGESTIONATA);
  1152.         if(oPddCongestionataThread instanceof Boolean){
  1153.             isPddCongestionataInformazioneIdentificataDalThread = (Boolean) oPddCongestionataThread;
  1154.         }
  1155.         
  1156.         StatoTraffico statoControlloCongestione = gestoreControlloCongestione.getStatoControlloTraffico();
  1157.         if(statoControlloCongestione.isPddCongestionata()!=isPddCongestionataInformazioneIdentificataDalThread){
  1158.             /**System.out.println("Rilevata differenza tra controllo del traffico attivo PREINHANDLER ["+controlloTrafficoAttivoThread+"] e stato attuale["+statoControlloCongestione.getControlloTraffico()+"]");*/
  1159.             pddContext.removeObject(CostantiControlloTraffico.PDD_CONTEXT_PDD_CONGESTIONATA);
  1160.             pddContext.addObject(CostantiControlloTraffico.PDD_CONTEXT_PDD_CONGESTIONATA, statoControlloCongestione.isPddCongestionata());
  1161.         }
  1162.         
  1163.         // Aggiungo al msgDiag i valori delle tre costanti poichè mi servirà anche per diagnostici durante la verifica delle policy.
  1164.         // Vanno aggiunti anche se la pdd non risulta congestionata
  1165.         
  1166.         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_ACTIVE_THREADS, statoControlloCongestione.getActiveThreads()+"");
  1167.         pddContext.addObject(GeneratoreMessaggiErrore.PDD_CONTEXT_ACTIVE_THREADS, statoControlloCongestione.getActiveThreads());
  1168.         
  1169.         Object oMaxThreads = pddContext.getObject(GeneratoreMessaggiErrore.PDD_CONTEXT_MAX_THREADS_THRESHOLD);
  1170.         if(oMaxThreads!=null){
  1171.             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_MAX_THREADS_THRESHOLD, oMaxThreads.toString());
  1172.         }
  1173.         
  1174.         Object oThreshold = pddContext.getObject(GeneratoreMessaggiErrore.PDD_CONTEXT_CONTROLLO_TRAFFICO_THRESHOLD);
  1175.         if(oThreshold!=null){
  1176.             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_CONTROLLO_TRAFFICO_THRESHOLD, oThreshold.toString());
  1177.         }
  1178.         
  1179.         if(statoControlloCongestione.isPddCongestionata()){
  1180.             // Emetto qua il diagnostico che la porta è congestionata.
  1181.             // Potrei emetterlo anche nel preInHandler, però lo emetto anzi qua perche viene poi usato qua la condizione per capire se attivare o meno una policy.
  1182.             
  1183.             
  1184.             // Aggiunto come evento della transazione l'informazione che la PdD è congestionata
  1185.             tr.addEventoGestione(TipoEvento.CONTROLLO_TRAFFICO_SOGLIA_CONGESTIONE.getValue()+"_"+CodiceEventoControlloTraffico.VIOLAZIONE.getValue());
  1186.             
  1187.             
  1188.             // Emetto Diagnostico Controllo del Traffico Attivato
  1189.             msgDiag.logPersonalizzato(GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_CONTROLLO_TRAFFICO_PDD_CONGESTIONATA);
  1190.             
  1191.         }
  1192.         
  1193.         return statoControlloCongestione.isPddCongestionata();
  1194.     }
  1195.     
  1196.     
  1197.     // Ritorna un MsgDiagnostico generator
  1198.     private MsgDiagnostico buildMsgDiagnostico(InRequestProtocolContext context) throws HandlerException{
  1199.         MsgDiagnostico msgDiag = null;
  1200.         try{
  1201.             String nomePorta = null;
  1202.             if(context.getIntegrazione()!=null) {
  1203.                 if(context.getIntegrazione().getIdPA()!=null) {
  1204.                     nomePorta = context.getIntegrazione().getIdPA().getNome();
  1205.                 }
  1206.                 else if(context.getIntegrazione().getIdPD()!=null) {
  1207.                     nomePorta = context.getIntegrazione().getIdPD().getNome();
  1208.                 }
  1209.             }
  1210.             
  1211.             RequestInfo requestInfo = null;
  1212.             if(context.getPddContext()!=null && context.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)) {
  1213.                 requestInfo = (RequestInfo) context.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  1214.             }
  1215.             
  1216.             msgDiag = MsgDiagnostico.newInstance(context.getTipoPorta(),context.getIdModulo(),nomePorta, requestInfo);
  1217.             msgDiag.setPddContext(context.getPddContext(), context.getProtocolFactory());
  1218.             if(org.openspcoop2.core.constants.TipoPdD.DELEGATA.equals(context.getTipoPorta())){
  1219.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  1220.             }
  1221.             else{
  1222.                 msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_BUSTE);
  1223.             }
  1224.         }catch(Exception e){
  1225.             throw new HandlerException("Generazione Messaggio Diagnostico non riuscita: "+e.getMessage(), e);
  1226.         }
  1227.         return msgDiag;
  1228.     }
  1229.     

  1231. }
Created with JaCoCo 0.8.8.202204050719