PolicyVerifier.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.policy;

  22. import java.util.Date;
  23. import java.util.List;

  25. import org.apache.commons.lang.StringUtils;
  26. import org.openspcoop2.core.commons.CoreException;
  27. import org.openspcoop2.core.config.PortaApplicativa;
  28. import org.openspcoop2.core.config.PortaDelegata;
  29. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  30. import org.openspcoop2.core.controllo_traffico.AttivazionePolicy;
  31. import org.openspcoop2.core.controllo_traffico.beans.ActivePolicy;
  32. import org.openspcoop2.core.controllo_traffico.beans.DatiCollezionati;
  33. import org.openspcoop2.core.controllo_traffico.beans.DatiTransazione;
  34. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  35. import org.openspcoop2.core.controllo_traffico.beans.RisultatoStatistico;
  36. import org.openspcoop2.core.controllo_traffico.beans.RisultatoStato;
  37. import org.openspcoop2.core.controllo_traffico.beans.UniqueIdentifierUtilities;
  38. import org.openspcoop2.core.controllo_traffico.constants.RuoloPolicy;
  39. import org.openspcoop2.core.controllo_traffico.constants.TipoApplicabilita;
  40. import org.openspcoop2.core.controllo_traffico.constants.TipoControlloPeriodo;
  41. import org.openspcoop2.core.controllo_traffico.constants.TipoFinestra;
  42. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  43. import org.openspcoop2.core.controllo_traffico.driver.IGestorePolicyAttive;
  44. import org.openspcoop2.core.controllo_traffico.driver.PolicyGroupByActiveThreadsType;
  45. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  46. import org.openspcoop2.core.eventi.constants.CodiceEventoControlloTraffico;
  47. import org.openspcoop2.core.eventi.constants.TipoEvento;
  48. import org.openspcoop2.core.id.IDPortaApplicativa;
  49. import org.openspcoop2.core.id.IDPortaDelegata;
  50. import org.openspcoop2.core.id.IDServizio;
  51. import org.openspcoop2.core.id.IDSoggetto;
  52. import org.openspcoop2.core.mapping.MappingErogazionePortaApplicativa;
  53. import org.openspcoop2.core.mapping.MappingFruizionePortaDelegata;
  54. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  55. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  56. import org.openspcoop2.pdd.core.PdDContext;
  57. import org.openspcoop2.pdd.core.controllo_traffico.CategoriaEventoControlloTraffico;
  58. import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
  59. import org.openspcoop2.pdd.core.controllo_traffico.DatiTempiRisposta;
  60. import org.openspcoop2.pdd.core.controllo_traffico.GeneratoreMessaggiErrore;
  61. import org.openspcoop2.pdd.core.controllo_traffico.NotificatoreEventi;
  62. import org.openspcoop2.pdd.core.controllo_traffico.RisultatoVerificaPolicy;
  63. import org.openspcoop2.pdd.core.controllo_traffico.policy.config.PolicyConfiguration;
  64. import org.openspcoop2.pdd.core.controllo_traffico.policy.driver.GestorePolicyAttive;
  65. import org.openspcoop2.pdd.core.transazioni.Transaction;
  66. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  67. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  68. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  69. import org.openspcoop2.protocol.sdk.ProtocolException;
  70. import org.openspcoop2.protocol.sdk.state.IState;
  71. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  72. import org.openspcoop2.protocol.utils.PorteNamingUtils;
  73. import org.openspcoop2.utils.date.DateManager;
  74. import org.slf4j.Logger;

  76. /**     
  77.  * PolicyVerifier
  78.  *
  79.  * @author Poli Andrea (poli@link.it)
  80.  * @author $Author$
  81.  * @version $Rev$, $Date$
  82.  */
  83. public class PolicyVerifier {
  84.     
  85.     private PolicyVerifier() {}

  87.     private static List<String> listClusterNodes = null;
  88.     public static List<String> getListClusterNodes() {
  89.         return listClusterNodes;
  90.     }
  91.     public static void setListClusterNodes(List<String> listClusterNodes) {
  92.         PolicyVerifier.listClusterNodes = listClusterNodes;
  93.     }

  95.     public static RisultatoVerificaPolicy verifica(
  96.             ConfigurazionePdDManager configPdDManager, IProtocolFactory<?> protocolFactory,
  97.             IGestorePolicyAttive gestorePolicyAttive, PolicyConfiguration policyConfiguration, Logger logCC,
  98.             ActivePolicy activePolicy, 
  99.             IDUnivocoGroupByPolicy datiGroupBy, PdDContext pddContext,
  100.             MsgDiagnostico msgDiag, 
  101.             Transaction tr,
  102.             DatiTransazione datiTransazione, boolean isPddCongestionata, DatiTempiRisposta tempiRisposta,
  103.             List<Boolean> pddContextPolicyApplicabile, List<Boolean> pddContextPolicyViolata,
  104.             IState state) throws Exception{
  105.                 
  106.         RequestInfo requestInfo = null;
  107.         if(tr!=null) {
  108.             requestInfo = tr.getRequestInfo();
  109.         }
  110.         
  111.         // Tutti i restanti controlli sono effettuati usando il valore di datiCollezionatiReaded, che e' gia' stato modificato
  112.         // Inoltre e' stato re-inserito nella map come oggetto nuovo, quindi il valore dentro il metodo non subira' trasformazioni (essendo stato fatto il clone)
  113.         // E' possibile procedere con l'analisi rispetto al valore che possiedono il counter dentro questo scope.
  114.         
  115.         boolean policyAPI = activePolicy.getInstanceConfiguration().getFiltro()!=null && 
  116.                 activePolicy.getInstanceConfiguration().getFiltro().getNomePorta()!=null &&
  117.                 !"".equals(activePolicy.getInstanceConfiguration().getFiltro().getNomePorta());
  118.         boolean policyGlobale = !policyAPI;
  119.         
  120.         // Registro Threads (NOTA: non i contatori, quelli vegono aggiornati )
  121.         if(pddContext!=null && policyConfiguration!=null) {
  122.             PolicyDateUtils.setGestorePolicyConfigDateIntoContext(pddContext, policyConfiguration.getGestorePolicyConfigDate());
  123.         }
  124.         DatiCollezionati datiCollezionatiReaded = gestorePolicyAttive.getActiveThreadsPolicy(activePolicy,datiTransazione, state).
  125.                 registerStartRequest(logCC,datiTransazione.getIdTransazione(),datiGroupBy,pddContext);

  127.             
  128.         // check fatto solamente nel minuto precedente alla creazione dei nuovi Dati 
  129.         Date check = new Date(DateManager.getTimeMillis()-(1000*60));
  130.         if(datiCollezionatiReaded.getCreationDate().after(check)) {
  131.             String uniqueIdMap = null;
  132.             for (PolicyGroupByActiveThreadsType tipo : GestorePolicyAttive.getTipiGestoriAttivi()) {
  133.                 if(!tipo.equals(gestorePolicyAttive.getType())) {
  134.                     if(uniqueIdMap==null) {
  135.                         uniqueIdMap = UniqueIdentifierUtilities.getUniqueId(activePolicy.getInstanceConfiguration());
  136.                     }
  137.                     /**System.out.println("RIPULISCO in '"+tipo+"' ["+uniqueIdMap+"] !!!");*/
  138.                     GestorePolicyAttive.getInstance(tipo).removeActiveThreadsPolicyUnsafe(uniqueIdMap);
  139.                 }
  140.             }
  141.         }
  142.         
  143.     
  144.         // Configuro Risultato
  145.         RisultatoVerificaPolicy risultatoVerificaPolicy = new RisultatoVerificaPolicy();
  146.         risultatoVerificaPolicy.setRisorsa(activePolicy.getTipoRisorsaPolicy());
  147.         risultatoVerificaPolicy.setSimultanee(activePolicy.getConfigurazionePolicy().isSimultanee());
  148.         risultatoVerificaPolicy.setWarningOnly(activePolicy.getInstanceConfiguration().isWarningOnly());
  149.         if(TipoApplicabilita.CONDIZIONALE.equals(activePolicy.getConfigurazionePolicy().getTipoApplicabilita())){
  150.             risultatoVerificaPolicy.setApplicabilitaCongestione(activePolicy.getConfigurazionePolicy().isApplicabilitaConCongestione());
  151.             risultatoVerificaPolicy.setApplicabilitaDegradoPrestazionale(activePolicy.getConfigurazionePolicy().isApplicabilitaDegradoPrestazionale());
  152.             risultatoVerificaPolicy.setApplicabilitaStatoAllarme(activePolicy.getConfigurazionePolicy().isApplicabilitaStatoAllarme());
  153.         }
  154.         
  155.         
  156.         GestoreCacheControlloTraffico gestoreCacheControlloTraffico = GestoreCacheControlloTraffico.getInstance();
  157.         
  158.         
  159.         boolean violazionePolicy = false;
  160.         boolean violazionePolicyWarningOnly = false;
  161.         Date dataEventoPolicyViolated = null;
  162.         String descriptionPolicyViolated = null; // non è definibile una descrizione, poichè si riferisce ad un evento qualsiasi di questo tipo
  163.     
  164.         /**System.out.println("ATTUALI THREADS: "+counter);*/
  165.     
  166.         try{
  167.         
  168.             Date now = datiCollezionatiReaded.getCloneDate(); // Data in cui sono stati prelevati gli intervalli.
  169.             
  170.             
  171.             // Imposto Dati Comuni
  172.             // questa info finisce nel diagnostico di una transazione, che possiede già tutte le informazioni di istanza (fruitore, erogatore, ...)
  173.             // Non serve quindi che aggiungo anche i dati relativi allo specifico group by
  174.             boolean printDati = false;
  175.             String toStringRaggruppamentoSenzaDatiIstanza = PolicyUtilities.toStringGroupBy(activePolicy.getInstanceConfiguration().getGroupBy(), datiGroupBy, printDati);
  176.             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_GRUPPO, toStringRaggruppamentoSenzaDatiIstanza);
  177.             
  178.             
  179.             
  180.                         
  181.             // ************ APPLICABILITA *************
  182.             
  183.             boolean isApplicabile = true;
  184.             String descrizioneNonApplicabile = null;
  185.             
  186.             // verifico che il sistema risulti congestionato prima di applicare la policy
  187.             if(risultatoVerificaPolicy.isApplicabilitaCongestione() &&
  188.                 
  189.                 !isPddCongestionata){
  190.                     
  191.                 isApplicabile = false;
  192.                 
  193.                 Object oThreshold = pddContext.getObject(GeneratoreMessaggiErrore.PDD_CONTEXT_CONTROLLO_TRAFFICO_THRESHOLD);
  194.                 if(oThreshold!=null){
  195.                     descrizioneNonApplicabile = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  196.                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_PDD_NON_CONGESTIONATA);
  197.                 }
  198.                 else{
  199.                     descrizioneNonApplicabile = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  200.                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_PDD_NON_CONGESTIONATA_CONTROLLO_DISABILITATO);
  201.                 }
  202.                 
  203.             }
  204.             
  205.             // verifico che il sistema risulti in degrado prestazionale
  206.             String descrizioneDegradoPrestazionaleRilevato = null;
  207.             if(isApplicabile && risultatoVerificaPolicy.isApplicabilitaDegradoPrestazionale()){
  208.                 
  209.                 Date leftDate = null;
  210.                 Date rightDate = null;
  211.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione())){
  212.                     leftDate = datiCollezionatiReaded.getDegradoPrestazionaleLeftDateWindowCurrentInterval();
  213.                     rightDate = datiCollezionatiReaded.getDegradoPrestazionaleRightDateWindowCurrentInterval();
  214.                 }
  215.                 else if(TipoFinestra.PRECEDENTE.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione())){
  216.                     leftDate = datiCollezionatiReaded.getDegradoPrestazionaleLeftDateWindowPrecedentInterval();
  217.                     rightDate = datiCollezionatiReaded.getDegradoPrestazionaleRightDateWindowPrecedentInterval();
  218.                 }
  219.                 else if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione())){
  220.                     leftDate = datiCollezionatiReaded.getDegradoPrestazionaleLeftDateWindowSlidingInterval(now);
  221.                     rightDate = datiCollezionatiReaded.getDegradoPrestazionaleRightDateWindowSlidingInterval(now);
  222.                 }
  223.                 Date checkDate = null;
  224.                 
  225.                 long valoreAttuale = 0;
  226.                 if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeModalitaControllo())){
  227.                     checkDate = now;
  228.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione())){
  229.                         if(datiCollezionatiReaded.getPolicyDegradoPrestazionaleAvgValue()!=null){
  230.                             valoreAttuale = datiCollezionatiReaded.getPolicyDegradoPrestazionaleAvgValue().longValue();
  231.                         }
  232.                     }
  233.                     else{
  234.                         // TipoFinestra.PRECEDENTE
  235.                         if(datiCollezionatiReaded.getOldPolicyDegradoPrestazionaleAvgValue()!=null){
  236.                             valoreAttuale = datiCollezionatiReaded.getOldPolicyDegradoPrestazionaleAvgValue().longValue();
  237.                         }
  238.                     }
  239.                 }
  240.                 else{
  241.                     RisultatoStatistico risultatoStatistico = gestoreCacheControlloTraffico.readLatenza(
  242.                             TipoRisorsa.TEMPO_MEDIO_RISPOSTA, // Di fatto se gia' è presente in cache, è la stessa informazione calcolata per la risorsa, se i parametri sono gli stessi
  243.                             leftDate,rightDate,
  244.                             activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione(),
  245.                             activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoIntervalloOsservazioneStatistico(), 
  246.                             activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoLatenza(),
  247.                             datiTransazione, datiGroupBy, activePolicy.getInstanceConfiguration().getFiltro(),
  248.                             state, requestInfo, protocolFactory);
  249.                     valoreAttuale = risultatoStatistico.getRisultato();
  250.                     checkDate = risultatoStatistico.getDateCheck();
  251.                 }
  252.                 
  253.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_TIPOLOGIA_TEMPO_MEDIO, "Latenza "+
  254.                         activePolicy.getConfigurazionePolicy().getDegradoAvgTimeTipoLatenza().getValue());
  255.                 
  256.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_AVG_TIME_RILEVATO, valoreAttuale+"");
  257.                 
  258.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VALORE_SOGLIA_DEGRADO_PRESTAZIONALE, tempiRisposta.getAvgResponseTime()+"");
  259.                 
  260.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_INTERVALLO_TEMPORALE,
  261.                         PolicyDateUtils.toStringIntervalloTemporale(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeFinestraOsservazione(), 
  262.                                 leftDate, rightDate, checkDate, 
  263.                                 TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getDegradoAvgTimeModalitaControllo())));
  264.                 
  265.                 if(valoreAttuale<=tempiRisposta.getAvgResponseTime()){
  266.                     
  267.                     isApplicabile = false;
  268.                                         
  269.                     descrizioneNonApplicabile = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  270.                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_DEGRADO_PRESTAZIONALE_NON_RILEVATO);
  271.                 }
  272.                 else{
  273.                     descrizioneDegradoPrestazionaleRilevato = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  274.                             GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_DEGRADO_PRESTAZIONALE_RILEVATO);
  275.                 }
  276.                 
  277.             }
  278.             
  279.             // verifico sullo stato di un allarme
  280.             String descrizioneStatoAllarmeRilevato = null;
  281.             if(isApplicabile && risultatoVerificaPolicy.isApplicabilitaStatoAllarme()){
  282.                 
  283.                 if(!((ConfigurazioneGatewayControlloTraffico)activePolicy.getConfigurazioneControlloTraffico()).isNotifierEnabled()){
  284.                     throw new CoreException("Modulo Allarmi non abilitato. La Policy deve essere applicata condizionalmente allo stato di un allarme");
  285.                 }
  286.                 
  287.                 RisultatoStato statoAttuale = null;
  288.                 String nomeAllarme = activePolicy.getConfigurazionePolicy().getAllarmeNome();
  289.                 msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_NOME_ALLARME, nomeAllarme);
  290.                 Integer statoIndicato = activePolicy.getConfigurazionePolicy().getAllarmeStato();
  291.                 boolean notStato = activePolicy.getConfigurazionePolicy().isAllarmeNotStato();
  292.                 try{
  293.                     statoAttuale = gestoreCacheControlloTraffico.getStato(datiTransazione,state,nomeAllarme);
  294.                 }catch(Exception e){
  295.                     isApplicabile = false;
  296.                     descrizioneNonApplicabile = "Recupero stato dell'allarme ["+nomeAllarme+"] non riuscito: "+e.getMessage();
  297.                 }
  298.                 if(statoAttuale!=null){
  299.                     
  300.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_STATO_ALLARME, PolicyUtilities.toString(statoAttuale));
  301.                     
  302.                     boolean match = false;
  303.                     if(notStato){
  304.                         match = statoAttuale.getStato().intValue()!=statoIndicato.intValue();
  305.                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_STATO_ALLARME_ATTESO, "stato differente da '"+PolicyUtilities.toString(statoIndicato)+"'");
  306.                     }else{
  307.                         match = statoAttuale.getStato().intValue()==statoIndicato.intValue();
  308.                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_STATO_ALLARME_ATTESO, "stato uguale a '"+PolicyUtilities.toString(statoIndicato)+"'");
  309.                     }
  310.                     if(!match){
  311.                         isApplicabile = false;
  312.                         
  313.                         descrizioneNonApplicabile = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  314.                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_STATO_ALLARME_NON_RILEVATO);
  315.                     }
  316.                     else{
  317.                         descrizioneStatoAllarmeRilevato = msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  318.                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_APPLICABILITA_STATO_ALLARME_RILEVATO);
  319.                     }
  320.                 }
  321.                 
  322.             }
  323.             
  324.             // aggiorno contatori
  325.             if(isApplicabile || !activePolicy.getConfigurazioneControlloTraffico().isElaborazioneRealtime_incrementaSoloPolicyApplicabile()){
  326.             
  327.                 DatiCollezionati datiCollezionatiUpdated = gestorePolicyAttive.getActiveThreadsPolicy(activePolicy,datiTransazione, state).
  328.                         updateDatiStartRequestApplicabile(logCC, datiTransazione.getIdTransazione(), datiGroupBy,pddContext);
  329.                 if(datiCollezionatiUpdated!=null) {
  330.                     datiCollezionatiReaded = datiCollezionatiUpdated; 
  331.                     now = datiCollezionatiReaded.getCloneDate(); // Data in cui sono stati prelevati gli intervalli.
  332.                 }
  333.                 
  334.                 pddContextPolicyApplicabile.add(true);
  335.             }
  336.             else{
  337.                 pddContextPolicyApplicabile.add(false);
  338.             }
  339.             
  340.             // resoconto finale
  341.             if(!isApplicabile){
  342.                 risultatoVerificaPolicy.setNonApplicabile(true);
  343.                 risultatoVerificaPolicy.setDescrizione(descrizioneNonApplicabile);
  344.                                 
  345.                 pddContextPolicyViolata.add(false);
  346.                 
  347.                 return risultatoVerificaPolicy;
  348.             }

  350.             

  352.             
  353.             
  354.             
  355.             
  356.             
  357.             // ************ VERIFICA POLICY *************
  358.             
  359.             long valoreSoglia = activePolicy.getConfigurazionePolicy().getValore();
  360.             if (activePolicy.getInstanceConfiguration().isRidefinisci()){
  361.                 valoreSoglia = activePolicy.getInstanceConfiguration().getValore();
  362.             }
  363.             
  364.             // ** La quota può essere suddivisa tra i nodi del cluster attivi ** 
  365.             boolean gestioneClusterSupportata = false;
  366.             long valoreSogliaComplessivoCluster = -1;
  367.             if(activePolicy.getConfigurazionePolicy().isSimultanee() ||
  368.                     TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())) {
  369.                 
  370.                 switch (activePolicy.getTipoRisorsaPolicy()) {
  371.                 
  372.                     case DIMENSIONE_MASSIMA_MESSAGGIO:
  373.                         // non viene viene verificata dal PolicyVerifier 
  374.                         break;
  375.                         
  376.                     case NUMERO_RICHIESTE:
  377.                     case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  378.                     case NUMERO_RICHIESTE_FALLITE:
  379.                     case NUMERO_FAULT_APPLICATIVI:
  380.                     case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  381.                     case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  382.                         gestioneClusterSupportata = true;
  383.                         break;
  384.                         
  385.                     case OCCUPAZIONE_BANDA:
  386.                         gestioneClusterSupportata = false;
  387.                         break;
  388.                         
  389.                     case TEMPO_COMPLESSIVO_RISPOSTA:
  390.                         gestioneClusterSupportata = false;
  391.                         break;
  392.                         
  393.                     case TEMPO_MEDIO_RISPOSTA:
  394.                         gestioneClusterSupportata = false;
  395.                         break;
  396.                 }
  397.                 
  398.                 if(!PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES.equals(policyConfiguration.getType())) {
  399.                     gestioneClusterSupportata = false;
  400.                 }
  401.                 
  402.                 if(gestioneClusterSupportata && PolicyGroupByActiveThreadsType.LOCAL_DIVIDED_BY_NODES.equals(policyConfiguration.getType()) && 
  403.                         listClusterNodes!=null && !listClusterNodes.isEmpty() && listClusterNodes.size()>1) {
  404.                     
  405.                     if(!policyConfiguration.isLOCAL_DIVIDED_BY_NODES_limit_normalizedQuota()) {
  406.                         risultatoVerificaPolicy.setMaxValueBeforeNormalizing(valoreSoglia);
  407.                     }
  408.                     
  409.                     risultatoVerificaPolicy.setRemainingZeroValue(policyConfiguration.isLOCAL_DIVIDED_BY_NODES_remaining_zeroValue());
  410.                     
  411.                     // La quota indicata verra suddivisa per difetto, e se la divisione non consente di avere un numero maggiore di 0 viene associato il valore 1 ad ogni nodo.
  412.                     long resto = -1;
  413.                     if(!policyConfiguration.isLOCAL_DIVIDED_BY_NODES_limit_roundingDown()) {
  414.                         resto = valoreSoglia % (listClusterNodes.size());
  415.                     }
  416.                     valoreSoglia = valoreSoglia / (listClusterNodes.size());
  417.                     if(policyConfiguration.isLOCAL_DIVIDED_BY_NODES_limit_roundingDown()) {
  418.                         if(valoreSoglia<=0) {
  419.                             valoreSoglia = 1;
  420.                         }
  421.                     }
  422.                     else {
  423.                         if(resto>0) {
  424.                             valoreSoglia = valoreSoglia + 1;
  425.                         }
  426.                     }
  427.                     
  428.                     valoreSogliaComplessivoCluster = valoreSoglia * (listClusterNodes.size());
  429.                     
  430.                 }
  431.                 else {
  432.                     gestioneClusterSupportata = false;
  433.                 }
  434.             }
  435.             
  436.             msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VALORE_SOGLIA, valoreSoglia+"");

  438.             boolean rilevataViolazione = false;
  439.             
  440.             switch (activePolicy.getTipoRisorsaPolicy()) {
  441.             
  442.             case DIMENSIONE_MASSIMA_MESSAGGIO:
  443.                 // non viene viene verificata dal PolicyVerifier 
  444.                 break;
  445.             
  446.             case NUMERO_RICHIESTE:
  447.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  448.             case NUMERO_RICHIESTE_FALLITE:
  449.             case NUMERO_FAULT_APPLICATIVI:
  450.             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  451.             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  452.                 
  453.                 if(activePolicy.getConfigurazionePolicy().isSimultanee()){
  454.                     
  455.                     long valoreAttuale = datiCollezionatiReaded.getActiveRequestCounter();
  456.                     if(gestioneClusterSupportata) {
  457.                         //  Gli header 'RateLimit-Remaining' verranno valorizzati per difetto rispetto al numero di nodi attivi.
  458.                         risultatoVerificaPolicy.setActualValue(valoreAttuale*(listClusterNodes.size()));
  459.                         risultatoVerificaPolicy.setMaxValue(valoreSogliaComplessivoCluster);
  460.                     }
  461.                     else {
  462.                         risultatoVerificaPolicy.setActualValue(valoreAttuale);
  463.                         risultatoVerificaPolicy.setMaxValue(valoreSoglia);
  464.                     }
  465.                     if(datiCollezionatiReaded.getRightDateWindowCurrentInterval()!=null) {
  466.                         risultatoVerificaPolicy.setMsBeforeResetCounters(datiCollezionatiReaded.getRightDateWindowCurrentInterval().getTime()-DateManager.getTimeMillis());
  467.                     }
  468.                     if(valoreAttuale>valoreSoglia){
  469.                         
  470.                         /**System.out.println("@@@addThread ERR NUMERO_RICHIESTE SIMULTANEE ["+datiCollezionatiReaded.getActiveRequestCounter()+"]<=["+valoreSoglia
  471.                             +"] WarningOnly["+risultatoVerificaPolicy.isWarningOnly()+"]");*/
  472.                         
  473.                         rilevataViolazione = true;
  474.                         risultatoVerificaPolicy.
  475.                             setDescrizione(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  476.                                     GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE_SIMULTANEE));
  477.                         
  478.                     }
  479.                     
  480.                 }
  481.                 else{
  482.                                     
  483.                     Date leftDate = null;
  484.                     Date rightDate = null;
  485.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  486.                         leftDate = datiCollezionatiReaded.getLeftDateWindowCurrentInterval();
  487.                         rightDate = datiCollezionatiReaded.getRightDateWindowCurrentInterval();
  488.                     }
  489.                     else if(TipoFinestra.PRECEDENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  490.                         leftDate = datiCollezionatiReaded.getLeftDateWindowPrecedentInterval();
  491.                         rightDate = datiCollezionatiReaded.getRightDateWindowPrecedentInterval();
  492.                     }
  493.                     else if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  494.                         leftDate = datiCollezionatiReaded.getLeftDateWindowSlidingInterval(now);
  495.                         rightDate = datiCollezionatiReaded.getRightDateWindowSlidingInterval(now);
  496.                     }
  497.                     Date checkDate = null;
  498.                     
  499.                     long valoreAttuale = 0;
  500.                     if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  501.                         checkDate = now;
  502.                         if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  503.                             if(datiCollezionatiReaded.getPolicyRequestCounter()!=null){
  504.                                 valoreAttuale = datiCollezionatiReaded.getPolicyRequestCounter().longValue();
  505.                                 switch (activePolicy.getTipoRisorsaPolicy()) {
  506.                                 case NUMERO_RICHIESTE:
  507.                                     break;
  508.                                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  509.                                 case NUMERO_RICHIESTE_FALLITE:
  510.                                 case NUMERO_FAULT_APPLICATIVI:
  511.                                 case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  512.                                 case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  513.                                     // se sono in uno tra questi 4 casi il contatore delle richieste in essere viene incrementato solo dopo aver consegnato la risposta (check esito).
  514.                                     // poichè però il controllo sotto è con <= devo considerare la richiesta in essere con '+1'
  515.                                     // altrimenti se ad es. il limite è 3, e sono già passate in passato 3 richieste, la 4 passa.
  516.                                     valoreAttuale = valoreAttuale +1;
  517.                                     break;
  518.                                 default:
  519.                                     break;
  520.                                 }
  521.                             }
  522.                         }
  523.                         else{
  524.                             // TipoFinestra.PRECEDENTE
  525.                             if(datiCollezionatiReaded.getOldPolicyRequestCounter()!=null){
  526.                                 valoreAttuale = datiCollezionatiReaded.getOldPolicyRequestCounter().longValue();
  527.                             }
  528.                         }
  529.                     }
  530.                     else{
  531.                         RisultatoStatistico risultatoStatistico = gestoreCacheControlloTraffico.readNumeroRichieste(activePolicy.getTipoRisorsaPolicy(),
  532.                                 leftDate,rightDate,
  533.                                 activePolicy.getConfigurazionePolicy().getFinestraOsservazione(),
  534.                                 activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico(), 
  535.                                 datiTransazione, datiGroupBy, activePolicy.getInstanceConfiguration().getFiltro(),
  536.                                 state, requestInfo, protocolFactory);
  537.                         valoreAttuale = risultatoStatistico.getRisultato();
  538.                         checkDate = risultatoStatistico.getDateCheck();
  539.                     }
  540.                             
  541.                     if(gestioneClusterSupportata) {
  542.                         //  Gli header 'RateLimit-Remaining' verranno valorizzati per difetto rispetto al numero di nodi attivi.
  543.                         risultatoVerificaPolicy.setActualValue(valoreAttuale*(listClusterNodes.size()));
  544.                         risultatoVerificaPolicy.setMaxValue(valoreSogliaComplessivoCluster);
  545.                     }
  546.                     else {
  547.                         risultatoVerificaPolicy.setActualValue(valoreAttuale);
  548.                         risultatoVerificaPolicy.setMaxValue(valoreSoglia);
  549.                     }
  550.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione()) || 
  551.                             TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  552.                         if(rightDate!=null) {
  553.                             risultatoVerificaPolicy.setMsBeforeResetCounters(rightDate.getTime()-DateManager.getTimeMillis());
  554.                         }
  555.                         if(leftDate!=null && rightDate!=null) {
  556.                             risultatoVerificaPolicy.setMsWindow((rightDate.getTime()+1)-leftDate.getTime());
  557.                         }
  558.                     }
  559.                     
  560.                     if(valoreAttuale>valoreSoglia){
  561.                         
  562.                         /**System.out.println("@@@addThread ERR NUMERO_RICHIESTE ["+valoreAttuale+"]<=["+valoreSoglia
  563.                             +"] WarningOnly["+risultatoVerificaPolicy.isWarningOnly()+"]");*/
  564.                         
  565.                         rilevataViolazione = true;
  566.                         
  567.                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VALORE_RILEVATO, valoreAttuale+"");
  568.                         
  569.                         msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_INTERVALLO_TEMPORALE,
  570.                                 PolicyDateUtils.toStringIntervalloTemporale(activePolicy.getConfigurazionePolicy().getFinestraOsservazione(), 
  571.                                         leftDate, rightDate, checkDate, 
  572.                                         TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())));
  573.                         
  574.                         String codeDiagnostico = null;
  575.                         switch (activePolicy.getTipoRisorsaPolicy()) {
  576.                             case NUMERO_RICHIESTE:
  577.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE;
  578.                                 break;
  579.                             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO:
  580.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO;
  581.                                 break;
  582.                             case NUMERO_RICHIESTE_FALLITE:
  583.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE_FALLITE;
  584.                                 break;
  585.                             case NUMERO_FAULT_APPLICATIVI:
  586.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_FAULT_APPLICATIVI;
  587.                                 break;
  588.                             case NUMERO_RICHIESTE_FALLITE_OFAULT_APPLICATIVI:
  589.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE_FALLITE_O_FAULT_APPLICATIVI;
  590.                                 break;
  591.                             case NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_OFAULT_APPLICATIVI:
  592.                                 codeDiagnostico = GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_NUMERO_RICHIESTE_COMPLETATE_CON_SUCCESSO_O_FAULT_APPLICATIVI;
  593.                                 break;
  594.                             default:
  595.                                 // non può succedere
  596.                                 break;
  597.                         }
  598.                         
  599.                         risultatoVerificaPolicy.
  600.                             setDescrizione(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, codeDiagnostico));
  601.                         
  602.                     }
  603.                     
  604.                 }
  605.                 
  606.                 break;
  607.                 
  608.             case OCCUPAZIONE_BANDA:
  609.                 
  610.                 Date leftDate = null;
  611.                 Date rightDate = null;
  612.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  613.                     leftDate = datiCollezionatiReaded.getLeftDateWindowCurrentInterval();
  614.                     rightDate = datiCollezionatiReaded.getRightDateWindowCurrentInterval();
  615.                 }
  616.                 else if(TipoFinestra.PRECEDENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  617.                     leftDate = datiCollezionatiReaded.getLeftDateWindowPrecedentInterval();
  618.                     rightDate = datiCollezionatiReaded.getRightDateWindowPrecedentInterval();
  619.                 }
  620.                 else if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  621.                     leftDate = datiCollezionatiReaded.getLeftDateWindowSlidingInterval(now);
  622.                     rightDate = datiCollezionatiReaded.getRightDateWindowSlidingInterval(now);
  623.                 }
  624.                 Date checkDate = null;
  625.                 
  626.                 long valoreAttuale = 0;
  627.                 if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  628.                     checkDate = now;
  629.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  630.                         if(datiCollezionatiReaded.getPolicyCounter()!=null){
  631.                             valoreAttuale = datiCollezionatiReaded.getPolicyCounter().longValue();
  632.                         }
  633.                     }
  634.                     else{
  635.                         // TipoFinestra.PRECEDENTE
  636.                         if(datiCollezionatiReaded.getOldPolicyCounter()!=null){
  637.                             valoreAttuale = datiCollezionatiReaded.getOldPolicyCounter().longValue();
  638.                         }
  639.                     }
  640.                 }
  641.                 else{
  642.                     RisultatoStatistico risultatoStatistico = gestoreCacheControlloTraffico.readOccupazioneBanda(activePolicy.getTipoRisorsaPolicy(),
  643.                             leftDate,rightDate,
  644.                             activePolicy.getConfigurazionePolicy().getFinestraOsservazione(),
  645.                             activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico(), 
  646.                             activePolicy.getConfigurazionePolicy().getValoreTipoBanda(),
  647.                             datiTransazione, datiGroupBy, activePolicy.getInstanceConfiguration().getFiltro(),
  648.                             state, requestInfo, protocolFactory);
  649.                     valoreAttuale = risultatoStatistico.getRisultato();
  650.                     checkDate = risultatoStatistico.getDateCheck();
  651.                     /**System.out.println("LETTO DA STATISTICA "+activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico()+
  652.                             " check("+org.openspcoop2.utils.date.DateUtils.getSimpleDateFormatMs().format(checkDate)+") intervallo '"+
  653.                             DateUtils.getSimpleDateFormatMs().format(leftDate)+"'-'"+
  654.                             DateUtils.getSimpleDateFormatMs().format(rightDate)+"': "+valoreAttuale);*/
  655.                 }
  656.                         
  657.                 long kb = DatiCollezionati.translateToKb(valoreAttuale);
  658.                 
  659.                 risultatoVerificaPolicy.setActualValue(kb);
  660.                 risultatoVerificaPolicy.setMaxValue(valoreSoglia);
  661.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione()) || 
  662.                         TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  663.                     if(rightDate!=null) {
  664.                         risultatoVerificaPolicy.setMsBeforeResetCounters(rightDate.getTime()-DateManager.getTimeMillis());
  665.                     }
  666.                     if(leftDate!=null && rightDate!=null) {
  667.                         risultatoVerificaPolicy.setMsWindow((rightDate.getTime()+1)-leftDate.getTime());
  668.                     }
  669.                 }
  670.                 
  671.                 if(kb>valoreSoglia){ 
  672.                     
  673.                     /**System.out.println("@@@addThread ERR OCCUPAZIONE BANDA ["+kb+"]<=["+valoreSoglia
  674.                         +"] WarningOnly["+risultatoVerificaPolicy.isWarningOnly()+"]");*/
  675.                     
  676.                     rilevataViolazione = true;
  677.                     
  678.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VALORE_RILEVATO, kb+"");
  679.                     
  680.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_INTERVALLO_TEMPORALE,
  681.                             PolicyDateUtils.toStringIntervalloTemporale(activePolicy.getConfigurazionePolicy().getFinestraOsservazione(), 
  682.                                     leftDate, rightDate, checkDate, 
  683.                                     TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())));
  684.                     
  685.                     risultatoVerificaPolicy.
  686.                         setDescrizione(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  687.                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_OCCUPAZIONE_BANDA));
  688.                     
  689.                 }
  690.                 
  691.                 break;
  692.     
  693.                 
  694.             case TEMPO_COMPLESSIVO_RISPOSTA:
  695.                 
  696.                 leftDate = null;
  697.                 rightDate = null;
  698.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  699.                     leftDate = datiCollezionatiReaded.getLeftDateWindowCurrentInterval();
  700.                     rightDate = datiCollezionatiReaded.getRightDateWindowCurrentInterval();
  701.                 }
  702.                 else if(TipoFinestra.PRECEDENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  703.                     leftDate = datiCollezionatiReaded.getLeftDateWindowPrecedentInterval();
  704.                     rightDate = datiCollezionatiReaded.getRightDateWindowPrecedentInterval();
  705.                 }
  706.                 else if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  707.                     leftDate = datiCollezionatiReaded.getLeftDateWindowSlidingInterval(now);
  708.                     rightDate = datiCollezionatiReaded.getRightDateWindowSlidingInterval(now);
  709.                 }
  710.                 checkDate = null;
  711.                 
  712.                 valoreAttuale = 0;
  713.                 if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  714.                     checkDate = now;
  715.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  716.                         if(datiCollezionatiReaded.getPolicyCounter()!=null){
  717.                             valoreAttuale = datiCollezionatiReaded.getPolicyCounter().longValue();
  718.                         }
  719.                     }
  720.                     else{
  721.                         // TipoFinestra.PRECEDENTE
  722.                         if(datiCollezionatiReaded.getOldPolicyCounter()!=null){
  723.                             valoreAttuale = datiCollezionatiReaded.getOldPolicyCounter().longValue();
  724.                         }
  725.                     }
  726.                 }
  727.                 else{
  728.                     throw new CoreException("Risorsa non utilizzabile con campionamento statistico");
  729.                 }
  730.                         
  731.                 long secondi = DatiCollezionati.translateToSeconds(valoreAttuale);
  732.                 
  733.                 risultatoVerificaPolicy.setActualValue(secondi);
  734.                 risultatoVerificaPolicy.setMaxValue(valoreSoglia);
  735.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione()) || 
  736.                         TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  737.                     if(rightDate!=null) {
  738.                         risultatoVerificaPolicy.setMsBeforeResetCounters(rightDate.getTime()-DateManager.getTimeMillis());
  739.                     }
  740.                     if(leftDate!=null && rightDate!=null) {
  741.                         risultatoVerificaPolicy.setMsWindow((rightDate.getTime()+1)-leftDate.getTime());
  742.                     }
  743.                 }
  744.                 
  745.                 if(secondi>valoreSoglia){ 
  746.                     
  747.                     /**System.out.println("@@@addThread ERR TEMPO COMPLESSIVO ["+secondi+"]<=["+valoreSoglia
  748.                         +"] WarningOnly["+risultatoVerificaPolicy.isWarningOnly()+"]");*/
  749.                     
  750.                     rilevataViolazione = true;
  751.                     
  752.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_VALORE_RILEVATO, secondi+"");
  753.                     
  754.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_INTERVALLO_TEMPORALE,
  755.                             PolicyDateUtils.toStringIntervalloTemporale(activePolicy.getConfigurazionePolicy().getFinestraOsservazione(), 
  756.                                     leftDate, rightDate, checkDate, 
  757.                                     TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())));
  758.                                         
  759.                     risultatoVerificaPolicy.
  760.                         setDescrizione(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  761.                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_TEMPO_COMPLESSIVO));
  762.                     
  763.                 }
  764.                 
  765.                 break;
  766.                 
  767.                 
  768.             case TEMPO_MEDIO_RISPOSTA:
  769.                 
  770.                 leftDate = null;
  771.                 rightDate = null;
  772.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  773.                     leftDate = datiCollezionatiReaded.getLeftDateWindowCurrentInterval();
  774.                     rightDate = datiCollezionatiReaded.getRightDateWindowCurrentInterval();
  775.                 }
  776.                 else if(TipoFinestra.PRECEDENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  777.                     leftDate = datiCollezionatiReaded.getLeftDateWindowPrecedentInterval();
  778.                     rightDate = datiCollezionatiReaded.getRightDateWindowPrecedentInterval();
  779.                 }
  780.                 else if(TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  781.                     leftDate = datiCollezionatiReaded.getLeftDateWindowSlidingInterval(now);
  782.                     rightDate = datiCollezionatiReaded.getRightDateWindowSlidingInterval(now);
  783.                 }
  784.                 checkDate = null;
  785.                 
  786.                 valoreAttuale = 0;
  787.                 if(TipoControlloPeriodo.REALTIME.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())){
  788.                     checkDate = now;
  789.                     if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  790.                         if(datiCollezionatiReaded.getPolicyAvgValue()!=null){
  791.                             valoreAttuale = datiCollezionatiReaded.getPolicyAvgValue().longValue();
  792.                         }
  793.                     }
  794.                     else{
  795.                         // TipoFinestra.PRECEDENTE
  796.                         if(datiCollezionatiReaded.getOldPolicyAvgValue()!=null){
  797.                             valoreAttuale = datiCollezionatiReaded.getOldPolicyAvgValue().longValue();
  798.                         }
  799.                     }
  800.                 }
  801.                 else{
  802.                     RisultatoStatistico risultatoStatistico = gestoreCacheControlloTraffico.readLatenza(activePolicy.getTipoRisorsaPolicy(),
  803.                             leftDate,rightDate,
  804.                             activePolicy.getConfigurazionePolicy().getFinestraOsservazione(),
  805.                             activePolicy.getConfigurazionePolicy().getTipoIntervalloOsservazioneStatistico(), 
  806.                             activePolicy.getConfigurazionePolicy().getValoreTipoLatenza(),
  807.                             datiTransazione, datiGroupBy, activePolicy.getInstanceConfiguration().getFiltro(),
  808.                             state, requestInfo, protocolFactory);
  809.                     valoreAttuale = risultatoStatistico.getRisultato();
  810.                     checkDate = risultatoStatistico.getDateCheck();
  811.                 }
  812.                     
  813.                 risultatoVerificaPolicy.setActualValue(valoreAttuale);
  814.                 risultatoVerificaPolicy.setMaxValue(valoreSoglia);
  815.                 if(TipoFinestra.CORRENTE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione()) || 
  816.                         TipoFinestra.SCORREVOLE.equals(activePolicy.getConfigurazionePolicy().getFinestraOsservazione())){
  817.                     if(rightDate!=null) {
  818.                         risultatoVerificaPolicy.setMsBeforeResetCounters(rightDate.getTime()-DateManager.getTimeMillis());
  819.                     }
  820.                     if(leftDate!=null && rightDate!=null) {
  821.                         risultatoVerificaPolicy.setMsWindow((rightDate.getTime()+1)-leftDate.getTime());
  822.                     }
  823.                 }
  824.                 
  825.                 if(valoreAttuale>valoreSoglia){
  826.                     
  827.                     /**System.out.println("@@@addThread ERR TEMPO MEDIO ["+valoreAttuale+"]<=["+valoreSoglia
  828.                         +"] WarningOnly["+risultatoVerificaPolicy.isWarningOnly()+"]");*/
  829.                     
  830.                     rilevataViolazione = true;
  831.                     
  832.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_TIPOLOGIA_TEMPO_MEDIO, "Latenza "+activePolicy.getConfigurazionePolicy().getValoreTipoLatenza().getValue());
  833.                                         
  834.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_AVG_TIME_RILEVATO, valoreAttuale+"");
  835.                         
  836.                     msgDiag.addKeyword(GeneratoreMessaggiErrore.TEMPLATE_POLICY_INTERVALLO_TEMPORALE,
  837.                             PolicyDateUtils.toStringIntervalloTemporale(activePolicy.getConfigurazionePolicy().getFinestraOsservazione(), 
  838.                                     leftDate, rightDate, checkDate, 
  839.                                     TipoControlloPeriodo.STATISTIC.equals(activePolicy.getConfigurazionePolicy().getModalitaControllo())));
  840.                     
  841.                     risultatoVerificaPolicy.
  842.                         setDescrizione(msgDiag.getMessaggio_replaceKeywords(MsgDiagnosticiProperties.MSG_DIAG_ALL, 
  843.                                 GeneratoreMessaggiErrore.MSG_DIAGNOSTICO_INTERCEPTOR_POLICY_VIOLATA_TEMPO_MEDIO));
  844.                     
  845.                 }
  846.                 
  847.                 break;
  848.     
  849.             }
  850.             
  851.             if(rilevataViolazione){
  852.                 TipoEvento tipoEvento = null;
  853.                 if(policyGlobale) {
  854.                     tipoEvento = TipoEvento.RATE_LIMITING_POLICY_GLOBALE;
  855.                 }
  856.                 else {
  857.                     tipoEvento = TipoEvento.RATE_LIMITING_POLICY_API;
  858.                 }
  859.                 if(risultatoVerificaPolicy.isWarningOnly()){
  860.                     violazionePolicyWarningOnly = true;
  861.                     tr.addEventoGestione(tipoEvento.getValue()
  862.                             +"_"+
  863.                             CodiceEventoControlloTraffico.VIOLAZIONE_WARNING_ONLY.getValue()
  864.                             +"_"+
  865.                             PolicyUtilities.getNomeActivePolicy(activePolicy.getInstanceConfiguration().getAlias(), activePolicy.getInstanceConfiguration().getIdActivePolicy())
  866.                         );
  867.                 }
  868.                 else{
  869.                     violazionePolicy = true;
  870.                     tr.addEventoGestione(tipoEvento.getValue()
  871.                             +"_"+
  872.                             CodiceEventoControlloTraffico.VIOLAZIONE.getValue()
  873.                             +"_"+
  874.                             PolicyUtilities.getNomeActivePolicy(activePolicy.getInstanceConfiguration().getAlias(), activePolicy.getInstanceConfiguration().getIdActivePolicy())
  875.                         );
  876.                 }
  877.                 dataEventoPolicyViolated = DateManager.getDate();
  878.                 
  879.                 // arricchisco descrizioni con eventuali descrizioni sulla applicabilità
  880.                 if(descrizioneDegradoPrestazionaleRilevato!=null){
  881.                     String separatore = "\n";
  882.                     if(!risultatoVerificaPolicy.getDescrizione().endsWith(".")){
  883.                         separatore = ".\n";
  884.                     }
  885.                     risultatoVerificaPolicy.setDescrizione(risultatoVerificaPolicy.getDescrizione()+separatore+descrizioneDegradoPrestazionaleRilevato);
  886.                 }
  887.                 if(descrizioneStatoAllarmeRilevato!=null){
  888.                     String separatore = "\n";
  889.                     if(!risultatoVerificaPolicy.getDescrizione().endsWith(".")){
  890.                         separatore = ".\n";
  891.                     }
  892.                     risultatoVerificaPolicy.setDescrizione(risultatoVerificaPolicy.getDescrizione()+separatore+descrizioneStatoAllarmeRilevato);
  893.                 }
  894.             }
  895.             
  896.             risultatoVerificaPolicy.setViolata(rilevataViolazione);
  897.             
  898.             pddContextPolicyViolata.add(rilevataViolazione);
  899.             
  900.             return risultatoVerificaPolicy;
  901.                 
  902.         }finally{
  903.             
  904.             if(pddContext!=null) {
  905.                 PolicyDateUtils.removeGestorePolicyConfigDateIntoContext(pddContext);
  906.             }
  907.             
  908.             // L'obiettivo è di generare un evento differente per ogni raggruppamento violato di una stessa policy
  909.             // All'interno di una stessa policy ci possono essere gruppi che non sono violati ed altri che lo sono
  910.             // Ad esempio se si raggruppa per soggetto fruitore, ci potranno essere soggetti che la violano, altri no.
  911.             // Si vuole un evento per ogni soggetto che viola la policy
  912.             String idPolicyConGruppo = null;
  913.             String configurazione = null;
  914.             if(violazionePolicy || violazionePolicyWarningOnly) {
  915.                 
  916.                 String idAPI = null;
  917.                 if(policyAPI) {
  918.                     idAPI = getIdAPI(activePolicy, protocolFactory, configPdDManager, requestInfo);
  919.                 }
  920.                 
  921.                 idPolicyConGruppo = PolicyUtilities.buildIdConfigurazioneEventoPerPolicy(activePolicy, datiGroupBy, idAPI);
  922.                 configurazione = PolicyUtilities.buildConfigurazioneEventoPerPolicy(activePolicy, policyGlobale);
  923.                 
  924.             }
  925.             
  926.             if(violazionePolicy){
  927.                 CategoriaEventoControlloTraffico tipoEvento = null;
  928.                 if(policyGlobale) {
  929.                     tipoEvento = CategoriaEventoControlloTraffico.POLICY_GLOBALE;
  930.                 }
  931.                 else {
  932.                     tipoEvento = CategoriaEventoControlloTraffico.POLICY_API;
  933.                 }
  934.                 NotificatoreEventi.getInstance().log(tipoEvento, 
  935.                         idPolicyConGruppo, configurazione,
  936.                         dataEventoPolicyViolated, descriptionPolicyViolated); 
  937.             }
  938.             if(violazionePolicyWarningOnly){
  939.                 CategoriaEventoControlloTraffico tipoEvento = null;
  940.                 if(policyGlobale) {
  941.                     tipoEvento = CategoriaEventoControlloTraffico.POLICY_GLOBALE_WARNING_ONLY;
  942.                 }
  943.                 else {
  944.                     tipoEvento = CategoriaEventoControlloTraffico.POLICY_API_WARNING_ONLY;
  945.                 }
  946.                 NotificatoreEventi.getInstance().log(tipoEvento, 
  947.                         idPolicyConGruppo, configurazione,
  948.                         dataEventoPolicyViolated, descriptionPolicyViolated); 
  949.             }
  950.             
  951.         }

  953.     }
  954.     
  955.     public static String getIdAPI(ActivePolicy activePolicy, IProtocolFactory<?> protocolFactory, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo) throws ProtocolException, DriverConfigurazioneException {
  956.         AttivazionePolicy attivazionePolicy = activePolicy.getInstanceConfiguration();
  957.         return getIdAPI(attivazionePolicy, protocolFactory, configPdDManager, requestInfo);
  958.     }
  959.     public static String getIdAPI(AttivazionePolicy attivazionePolicy, IProtocolFactory<?> protocolFactory, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo) throws ProtocolException, DriverConfigurazioneException {
  960.         PorteNamingUtils namingUtils = new PorteNamingUtils(protocolFactory);
  961.         
  962.         String api = null;
  963.         
  964.         if(attivazionePolicy.getFiltro()!=null &&
  965.                 attivazionePolicy.getFiltro().getNomePorta()!=null && 
  966.                 StringUtils.isNotEmpty(attivazionePolicy.getFiltro().getNomePorta()) && 
  967.                 attivazionePolicy.getFiltro().getRuoloPorta()!=null) {
  968.             String nomePorta = attivazionePolicy.getFiltro().getNomePorta();
  969.             if(RuoloPolicy.DELEGATA.equals(attivazionePolicy.getFiltro().getRuoloPorta())) {
  970.                 api = getIdAPIFruizione(nomePorta, configPdDManager, requestInfo, namingUtils);
  971.             }
  972.             else if(RuoloPolicy.APPLICATIVA.equals(attivazionePolicy.getFiltro().getRuoloPorta())) {
  973.                 api = getIdAPIErogazione(nomePorta, configPdDManager, requestInfo, namingUtils);
  974.             }
  975.         }
  976.         
  977.         return api;
  978.     }

  980.     public static PolicyDati getIdAPIFruizione(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException, ProtocolException {
  981.         PorteNamingUtils namingUtils = new PorteNamingUtils(protocolFactory);
  982.         PolicyDati dati = getIdAPIFruizioneEngine(nomePorta, configPdDManager, requestInfo, namingUtils);
  983.         if(protocolFactory!=null) {
  984.             dati.setProfilo(protocolFactory.getProtocol());
  985.         }
  986.         return dati;
  987.     }
  988.     public static String getIdAPIFruizione(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, PorteNamingUtils namingUtils) throws DriverConfigurazioneException, ProtocolException {
  989.         return getIdAPIFruizioneEngine(nomePorta, configPdDManager, requestInfo, namingUtils).getIdentificativo();
  990.     }
  991.     private static PolicyDati getIdAPIFruizioneEngine(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, PorteNamingUtils namingUtils) throws DriverConfigurazioneException, ProtocolException {
  992.         
  993.         PolicyDati policyDati = new PolicyDati();
  994.         policyDati.setRuoloPorta(RuoloPolicy.DELEGATA);
  995.         policyDati.setNomePorta(nomePorta);
  996.         
  997.         String api = null;
  998.         IDPortaDelegata idPD = new IDPortaDelegata();
  999.         idPD.setNome(nomePorta);
  1000.         PortaDelegata pd = configPdDManager.getPortaDelegataSafeMethod(idPD, requestInfo);
  1001.         if(pd!=null) {
  1002.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(pd.getServizio().getTipo(), pd.getServizio().getNome(), 
  1003.                     pd.getSoggettoErogatore().getTipo(), pd.getSoggettoErogatore().getNome(), 
  1004.                     pd.getServizio().getVersione());
  1005.             policyDati.setIdServizio(idServizio);
  1006.             
  1007.             IDSoggetto idFruitore = new IDSoggetto(pd.getTipoSoggettoProprietario(), pd.getNomeSoggettoProprietario());
  1008.             policyDati.setIdFruitore(idFruitore);
  1009.             
  1010.             List<MappingFruizionePortaDelegata> list = configPdDManager.getMappingFruizionePortaDelegataList(idFruitore, idServizio, requestInfo);
  1011.             if(list.size()<=1) {
  1012.                 api = namingUtils.normalizePD(nomePorta);
  1013.             }
  1014.             else {
  1015.                 String gruppo = null;
  1016.                 for (MappingFruizionePortaDelegata mapping : list) {
  1017.                     if(mapping.isDefault()) {
  1018.                         api = namingUtils.normalizePD(mapping.getIdPortaDelegata().getNome());
  1019.                     }
  1020.                     if(nomePorta.equals(mapping.getIdPortaDelegata().getNome())) {
  1021.                         gruppo = mapping.getDescrizione();
  1022.                     }
  1023.                 }
  1024.                 api = api + " (gruppo '"+gruppo+"'"+") ";
  1025.                 policyDati.setGruppo(gruppo);
  1026.             }
  1027.         }
  1028.         policyDati.setIdentificativo(api);
  1029.         
  1030.         return policyDati;
  1031.     }
  1032.     
  1033.     public static PolicyDati getIdAPIErogazione(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, IProtocolFactory<?> protocolFactory) throws DriverConfigurazioneException, ProtocolException {
  1034.         PorteNamingUtils namingUtils = new PorteNamingUtils(protocolFactory);
  1035.         PolicyDati dati = getIdAPIErogazioneEngine(nomePorta, configPdDManager, requestInfo, namingUtils);
  1036.         if(protocolFactory!=null) {
  1037.             dati.setProfilo(protocolFactory.getProtocol());
  1038.         }
  1039.         return dati;
  1040.     }
  1041.     public static String getIdAPIErogazione(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, PorteNamingUtils namingUtils) throws DriverConfigurazioneException, ProtocolException {
  1042.         return getIdAPIErogazioneEngine(nomePorta, configPdDManager, requestInfo, namingUtils).getIdentificativo();
  1043.     }
  1044.     private static PolicyDati getIdAPIErogazioneEngine(String nomePorta, ConfigurazionePdDManager configPdDManager, RequestInfo requestInfo, PorteNamingUtils namingUtils) throws DriverConfigurazioneException, ProtocolException {
  1045.         
  1046.         PolicyDati policyDati = new PolicyDati();
  1047.         policyDati.setRuoloPorta(RuoloPolicy.APPLICATIVA);
  1048.         policyDati.setNomePorta(nomePorta);
  1049.         
  1050.         String api = null;
  1051.         IDPortaApplicativa idPA = new IDPortaApplicativa();
  1052.         idPA.setNome(nomePorta);
  1053.         PortaApplicativa pa = configPdDManager.getPortaApplicativaSafeMethod(idPA, requestInfo);
  1054.         if(pa!=null) {
  1055.             IDServizio idServizio = IDServizioFactory.getInstance().getIDServizioFromValuesWithoutCheck(pa.getServizio().getTipo(), pa.getServizio().getNome(), 
  1056.                     pa.getTipoSoggettoProprietario(), pa.getNomeSoggettoProprietario(),
  1057.                     pa.getServizio().getVersione());
  1058.             policyDati.setIdServizio(idServizio);
  1059.             List<MappingErogazionePortaApplicativa> list = configPdDManager.getMappingErogazionePortaApplicativaList(idServizio, requestInfo);
  1060.             if(list.size()<=1) {
  1061.                 api = namingUtils.normalizePA(nomePorta);
  1062.             }
  1063.             else {
  1064.                 String gruppo = null;
  1065.                 for (MappingErogazionePortaApplicativa mapping : list) {
  1066.                     if(mapping.isDefault()) {
  1067.                         api = namingUtils.normalizePA(mapping.getIdPortaApplicativa().getNome());
  1068.                     }
  1069.                     if(nomePorta.equals(mapping.getIdPortaApplicativa().getNome())) {
  1070.                         gruppo = mapping.getDescrizione();
  1071.                     }
  1072.                 }
  1073.                 api = api + " (gruppo '"+gruppo+"'"+") ";
  1074.                 policyDati.setGruppo(gruppo);
  1075.             }
  1076.         }
  1077.         policyDati.setIdentificativo(api);
  1078.         
  1079.         return policyDati;
  1080.     }
  1081. }
Created with JaCoCo 0.8.8.202204050719