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.sdk.state.StateMessage;
  78. import org.openspcoop2.protocol.utils.EsitiProperties;
  79. import org.openspcoop2.utils.Utilities;
  80. import org.slf4j.Logger;

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

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

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

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

  295.             
  296.             try{
  297.                 

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

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

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

  799.             }
  800.             
  801.         }

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

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

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

  1245. }
Created with JaCoCo 0.8.8.202204050719