NotificatoreEventi.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it).
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.pdd.core.controllo_traffico;

  23. import java.io.File;
  24. import java.io.FileOutputStream;
  25. import java.io.InputStream;
  26. import java.io.OutputStream;
  27. import java.sql.Connection;
  28. import java.text.SimpleDateFormat;
  29. import java.util.Date;
  30. import java.util.HashMap;
  31. import java.util.Iterator;
  32. import java.util.Map;
  33. import java.util.zip.ZipEntry;
  34. import java.util.zip.ZipFile;
  35. import java.util.zip.ZipOutputStream;

  37. import javax.activation.FileDataSource;

  39. import org.openspcoop2.core.commons.CoreException;
  40. import org.openspcoop2.core.config.driver.DriverConfigurazioneException;
  41. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  42. import org.openspcoop2.core.eventi.Evento;
  43. import org.openspcoop2.core.eventi.constants.CodiceEventoControlloTraffico;
  44. import org.openspcoop2.core.eventi.constants.TipoEvento;
  45. import org.openspcoop2.core.eventi.constants.TipoSeverita;
  46. import org.openspcoop2.core.eventi.utils.SeveritaConverter;
  47. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  48. import org.openspcoop2.pdd.core.eventi.GestoreEventi;
  49. import org.openspcoop2.protocol.basic.Costanti;
  50. import org.openspcoop2.utils.SemaphoreLock;
  51. import org.openspcoop2.utils.Utilities;
  52. import org.openspcoop2.utils.UtilsException;
  53. import org.openspcoop2.utils.beans.WriteToSerializerType;
  54. import org.openspcoop2.utils.date.DateManager;
  55. import org.openspcoop2.utils.date.DateUtils;
  56. import org.openspcoop2.utils.io.ZipUtilities;
  57. import org.openspcoop2.utils.resources.FileSystemUtilities;
  58. import org.slf4j.Logger;

  60. /**     
  61.  * NotificatoreEventi
  62.  *
  63.  * @author Poli Andrea (poli@link.it)
  64.  * @author $Author$
  65.  * @version $Rev$, $Date$
  66.  */
  67. public class NotificatoreEventi {

  69.     private static NotificatoreEventi staticInstance = null;
  70.     private static synchronized void initialize() throws DriverConfigurazioneException {
  71.         if(staticInstance==null){
  72.             staticInstance = new NotificatoreEventi();
  73.         }
  74.     }
  75.     public static NotificatoreEventi getInstance() throws DriverConfigurazioneException {
  76.         if(staticInstance==null){
  77.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  78.             synchronized (NotificatoreEventi.class) {
  79.                 initialize();
  80.             }
  81.         }
  82.         return staticInstance;
  83.     }

  85.     private GestoreEventi gestoreEventi;
  86.         
  87.     private NotificatoreEventi() throws DriverConfigurazioneException {
  88.         this.gestoreEventi = GestoreEventi.getInstance();
  89.     }
  90.     
  91.     /**
  92.      * In memoria vengono collezionate (viene salvata la data):
  93.      * Eventi causati durante la gestione di un thread (denominati TH_EVENTO)
  94.      * - TH_lastMaxRequests. ultimo scarto di una richiesta per raggiungimento MaxThreads
  95.      * - TH_lastPddCongestionata. ultimo evento di rilevamento congestione della PdD
  96.      * - TH_lastPolicyViolated. ultimo scarto per violazione di una policy attiva
  97.      * - TH_lastPolicyViolated_warningOnly. ultimo di scarto per violazione di una policy attiva configurata in warning only
  98.      * 
  99.      * Inoltre in memoria vengono collezionati gli ultimi eventi emessi realmente emessi sul database degli eventi
  100.      * (viene salvato la tipologia dell'evento cioè se l'evento occorre 'INGRESSO', ad es. violazione,  
  101.      * o se l'evento termina 'USCITA', ad es. violazione-risolta) 
  102.      * per i quattro tipi sopra indicati (denominati con DB_EVENTO):
  103.      * - DB_lastMaxRequests. ultimo evento emesso su db per raggiungimento (o ritorno nei livelli soglia) da MaxThreads
  104.      * - DB_lastPddCongestionata.  ultimo evento di rilevamento congestione (fine congestione) della PdD
  105.      * - DB_lastPolicyViolated. ultimo evento emesso per scarto per violazione (o ritorno nei livelli soglia) di una policy attiva
  106.      * - DB_lastPolicyViolated_warningOnly. ultimo evento emesso per scarto per violazione (o ritorno nei livelli soglia) di una policy attiva in warning only
  107.      * 
  108.      * Esistera un timer che gira ogni x minuti.
  109.      * Per ogni TH_<tipo> effettua il seguente algoritmo (dove tipo e' uno dei quattro descritti in precedenza).
  110.      * if( esiste TH_<tipo> ultimo_intervallo_x_minuti ){
  111.      *      if( esiste DB_<tipo> ){
  112.      *          tipologia = DB_<tipo>.tipologia
  113.      *          if ( tipologia == "USCITA" ){
  114.      *              // emetto evento di ingresso, ho una variazione di stato
  115.      *              DB_<tipo> = emettoEventoSuDatabase(<tipo>,"INGRESSO")
  116.      *          }
  117.      *      }
  118.      *      else{
  119.      *          // primo evento
  120.      *          DB_<tipo> = emettoEventoSuDatabase(<tipo>,"INGRESSO")
  121.      *      }
  122.      * }
  123.      * else{
  124.      *      if( esiste DB_<tipo> ){
  125.      *          tipologia = DB_<tipo>.tipologia
  126.      *          if ( tipologia == "INGRESSO" ){
  127.      *              // emetto evento di uscita, ho una variazione di stato
  128.      *              DB_<tipo> = emettoEventoSuDatabase(<tipo>,"USCITA")
  129.      *          }
  130.      *      }   
  131.      * }
  132.      * 
  133.      * NOTA: Non ci interessa la visione di dettaglio. E' chiaro che se rilevo un evento di scarto nell'intervallo di 5 minuti
  134.      *       poi puo' darsi che nell'ultimo minuto il problema sia rientrato. Pero' io vorrei segnalare che c'e' stato il problema
  135.      *       Poi nel prossimo controllo, indichero' che il problema e' rientrato, pero' almeno so' che nella finestra temporale dei 5 minuti e' accaduto un errore.
  136.      *       
  137.      * NOTA: L'analisi di dettaglio puo' poi essere effettuata sulle transazioni ricercando le transazioni che contengono quell'evento.
  138.      */
  139.     
  140.     //private Boolean semaphore = true; // per gestire l'accesso alle risorse dal thread
  141.     private static final org.openspcoop2.utils.Semaphore lock = new org.openspcoop2.utils.Semaphore("NotificatoreEventi");
  142.     
  143.     // TH_EVENTO
  144.     private DatiEventoGenerico inMemoryLastMaxRequests = new DatiEventoGenerico();
  145.     private DatiEventoGenerico inMemoryLastMaxRequestsWarningOnly = new DatiEventoGenerico();
  146.     private DatiEventoGenerico inMemoryLastPddCongestionata = new DatiEventoGenerico();
  147.     private Map<String, DatiEventoGenerico> inMemoryLastPolicyGlobaliViolated = new HashMap<>();
  148.     private Map<String, DatiEventoGenerico> inMemoryLastPolicyGlobaliViolatedWarningOnly = new HashMap<>();
  149.     private Map<String, DatiEventoGenerico> inMemoryLastPolicyAPIViolated = new HashMap<>();
  150.     private Map<String, DatiEventoGenerico> inMemoryLastPolicyAPIViolatedWarningOnly = new HashMap<>();
  151.     private Map<String, DatiEventoGenerico> inMemoryLastTimeoutConnessione = new HashMap<>();
  152.     private Map<String, DatiEventoGenerico> inMemoryLastTimeoutRichiesta = new HashMap<>();
  153.     private Map<String, DatiEventoGenerico> inMemoryLastTimeoutRisposta = new HashMap<>();
  154.         
  155.     // DB_EVENTO
  156.     private DatabaseDatiEventoGenerico dbLastMaxRequests = new DatabaseDatiEventoGenerico();
  157.     private DatabaseDatiEventoGenerico dbLastMaxRequestsWarningOnly = new DatabaseDatiEventoGenerico();
  158.     private DatabaseDatiEventoGenerico dbLastPddCongestionata = new DatabaseDatiEventoGenerico();
  159.     private Map<String, DatabaseDatiEventoGenerico> dbLastPolicyGlobaliViolated = new HashMap<>();
  160.     private Map<String, DatabaseDatiEventoGenerico> dbLastPolicyGlobaliViolatedWarningOnly = new HashMap<>();
  161.     private Map<String, DatabaseDatiEventoGenerico> dbLastPolicyAPIViolated = new HashMap<>();
  162.     private Map<String, DatabaseDatiEventoGenerico> dbLastPolicyAPIViolatedWarningOnly = new HashMap<>();
  163.     private Map<String, DatabaseDatiEventoGenerico> dbLastTimeoutConnessione = new HashMap<>();
  164.     private Map<String, DatabaseDatiEventoGenerico> dbLastTimeoutRichiesta = new HashMap<>();
  165.     private Map<String, DatabaseDatiEventoGenerico> dbLastTimeoutRisposta = new HashMap<>();
  166.     
  167.     private static final String ID_POLICY_NON_FORNITA = "IdPolicy non fornita";
  168.     
  169.     public void log(CategoriaEventoControlloTraffico evento, Date date, String descrizione) throws CoreException,UtilsException{
  170.         log(evento, null, null, date, descrizione);
  171.     }
  172.     public void log(CategoriaEventoControlloTraffico evento, String idPolicy, String configurazione, Date date, String descrizione) throws CoreException,UtilsException{
  173.         
  174.         if(evento==null){
  175.             throw new CoreException("Evento non definito");
  176.         }
  177.         
  178.         switch (evento) {
  179.         
  180.         case LIMITE_GLOBALE_RICHIESTE_SIMULTANEE:{
  181.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  182.             try {
  183.                 if(this.inMemoryLastMaxRequests.datiConsumatiThread){
  184.                     if(date==null)
  185.                         this.inMemoryLastMaxRequests.data = DateManager.getDate();
  186.                     else
  187.                         this.inMemoryLastMaxRequests.data = date;
  188.                     this.inMemoryLastMaxRequests.descrizione = descrizione;
  189.                     this.inMemoryLastMaxRequests.configurazione = configurazione;
  190.                     /**System.out.println("@@LOG AGGIORNO DATA LIMITE_RICHIESTE_SIMULTANEE_VIOLAZIONE ["+
  191.                         newSimpleDateFormat().format(this.inMemoryLastMaxRequests.data)+"]");*/
  192.                     this.inMemoryLastMaxRequests.datiConsumatiThread=false;
  193.                 }
  194.             }finally {
  195.                 lock.release(slock, "log_"+evento.name());
  196.             }
  197.             break;
  198.         }
  199.         case LIMITE_GLOBALE_RICHIESTE_SIMULTANEE_WARNING_ONLY:{
  200.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  201.             try {
  202.                 if(this.inMemoryLastMaxRequestsWarningOnly.datiConsumatiThread){
  203.                     if(date==null)
  204.                         this.inMemoryLastMaxRequestsWarningOnly.data = DateManager.getDate();
  205.                     else
  206.                         this.inMemoryLastMaxRequestsWarningOnly.data = date;
  207.                     this.inMemoryLastMaxRequestsWarningOnly.descrizione = descrizione;
  208.                     this.inMemoryLastMaxRequestsWarningOnly.configurazione = configurazione;
  209.                     /**System.out.println("@@LOG AGGIORNO DATA LIMITE_RICHIESTE_SIMULTANEE_VIOLAZIONE WARNING_ONLY ["+
  210.                         newSimpleDateFormat().format(this.inMemoryLastMaxRequestsWarningOnly.data)+"]");*/
  211.                     this.inMemoryLastMaxRequestsWarningOnly.datiConsumatiThread=false;
  212.                 }
  213.             }finally {
  214.                 lock.release(slock, "log_"+evento.name());
  215.             }
  216.             break;
  217.         }
  218.         case CONGESTIONE_PORTA_DOMINIO:{
  219.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  220.             try {
  221.                 if(this.inMemoryLastPddCongestionata.datiConsumatiThread){
  222.                     if(date==null)
  223.                         this.inMemoryLastPddCongestionata.data = DateManager.getDate();
  224.                     else
  225.                         this.inMemoryLastPddCongestionata.data = date;
  226.                     this.inMemoryLastPddCongestionata.descrizione = descrizione;
  227.                     this.inMemoryLastPddCongestionata.configurazione = configurazione;
  228.                     /**System.out.println("@@LOG AGGIORNO DATA CONGESTIONE PDD ["+
  229.                         newSimpleDateFormat().format(this.inMemoryLastPddCongestionata.data)+"]");*/
  230.                     this.inMemoryLastPddCongestionata.datiConsumatiThread=false;
  231.                 }
  232.             }finally {
  233.                 lock.release(slock, "log_"+evento.name());
  234.             }
  235.             break;
  236.         }
  237.         case POLICY_GLOBALE:{
  238.             if(idPolicy==null){
  239.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  240.             }
  241.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  242.             try {
  243.                 if(!this.inMemoryLastPolicyGlobaliViolated.containsKey(idPolicy)){
  244.                     this.inMemoryLastPolicyGlobaliViolated.put(idPolicy, new DatiEventoGenerico());
  245.                 }
  246.                 if(!this.dbLastPolicyGlobaliViolated.containsKey(idPolicy)){
  247.                     this.dbLastPolicyGlobaliViolated.put(idPolicy, new DatabaseDatiEventoGenerico());
  248.                 }
  249.                 DatiEventoGenerico inMemoryLastPolicyGlobaleViolatedPolicy = this.inMemoryLastPolicyGlobaliViolated.get(idPolicy);
  250.                 
  251.                 if(inMemoryLastPolicyGlobaleViolatedPolicy.datiConsumatiThread){
  252.                     if(date==null)
  253.                         inMemoryLastPolicyGlobaleViolatedPolicy.data = DateManager.getDate();
  254.                     else
  255.                         inMemoryLastPolicyGlobaleViolatedPolicy.data = date;
  256.                     inMemoryLastPolicyGlobaleViolatedPolicy.descrizione = descrizione;
  257.                     inMemoryLastPolicyGlobaleViolatedPolicy.configurazione = configurazione;
  258.                     /**System.out.println("@@LOG AGGIORNO DATA POLICY VIOLAZIONE ["+
  259.                             newSimpleDateFormat().format(inMemoryLastPolicyGlobaleViolatedPolicy.data)+"]");*/
  260.                     inMemoryLastPolicyGlobaleViolatedPolicy.datiConsumatiThread=false;
  261.                 }
  262.             }finally {
  263.                 lock.release(slock, "log_"+evento.name());
  264.             }
  265.             break;
  266.         }
  267.         case POLICY_GLOBALE_WARNING_ONLY:{
  268.             if(idPolicy==null){
  269.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  270.             }
  271.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  272.             try {
  273.                 if(!this.inMemoryLastPolicyGlobaliViolatedWarningOnly.containsKey(idPolicy)){
  274.                     this.inMemoryLastPolicyGlobaliViolatedWarningOnly.put(idPolicy, new DatiEventoGenerico());
  275.                 }
  276.                 if(!this.dbLastPolicyGlobaliViolatedWarningOnly.containsKey(idPolicy)){
  277.                     this.dbLastPolicyGlobaliViolatedWarningOnly.put(idPolicy, new DatabaseDatiEventoGenerico());
  278.                 }
  279.                 DatiEventoGenerico inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy = this.inMemoryLastPolicyGlobaliViolatedWarningOnly.get(idPolicy);
  280.                 
  281.                 if(inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.datiConsumatiThread){
  282.                     if(date==null)
  283.                         inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.data = DateManager.getDate();
  284.                     else
  285.                         inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.data = date;
  286.                     inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.descrizione = descrizione;
  287.                     inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.configurazione = configurazione;
  288.                     /**System.out.println("@@LOG AGGIORNO DATA POLICY VIOLAZIONE WARNING_ONLY ["+
  289.                             newSimpleDateFormat().format(inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.data)+"]");*/
  290.                     inMemoryLastPolicyGlobaleViolatedWarningOnlyPolicy.datiConsumatiThread=false;
  291.                 }
  292.             }finally {
  293.                 lock.release(slock, "log_"+evento.name());
  294.             }
  295.             break;
  296.         }
  297.             
  298.         case POLICY_API:{
  299.             if(idPolicy==null){
  300.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  301.             }
  302.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  303.             try {
  304.                 if(!this.inMemoryLastPolicyAPIViolated.containsKey(idPolicy)){
  305.                     this.inMemoryLastPolicyAPIViolated.put(idPolicy, new DatiEventoGenerico());
  306.                 }
  307.                 if(!this.dbLastPolicyAPIViolated.containsKey(idPolicy)){
  308.                     this.dbLastPolicyAPIViolated.put(idPolicy, new DatabaseDatiEventoGenerico());
  309.                 }
  310.                 DatiEventoGenerico inMemoryLastPolicyAPIViolatedPolicy = this.inMemoryLastPolicyAPIViolated.get(idPolicy);
  311.                 
  312.                 if(inMemoryLastPolicyAPIViolatedPolicy.datiConsumatiThread){
  313.                     if(date==null)
  314.                         inMemoryLastPolicyAPIViolatedPolicy.data = DateManager.getDate();
  315.                     else
  316.                         inMemoryLastPolicyAPIViolatedPolicy.data = date;
  317.                     inMemoryLastPolicyAPIViolatedPolicy.descrizione = descrizione;
  318.                     inMemoryLastPolicyAPIViolatedPolicy.configurazione = configurazione;
  319.                     /**System.out.println("@@LOG AGGIORNO DATA POLICY VIOLAZIONE ["+
  320.                             newSimpleDateFormat().format(inMemoryLastPolicyAPIViolatedPolicy.data)+"]");*/
  321.                     inMemoryLastPolicyAPIViolatedPolicy.datiConsumatiThread=false;
  322.                 }
  323.             }finally {
  324.                 lock.release(slock, "log_"+evento.name());
  325.             }
  326.             break;
  327.         }
  328.         case POLICY_API_WARNING_ONLY:{
  329.             if(idPolicy==null){
  330.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  331.             }
  332.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  333.             try {
  334.                 if(!this.inMemoryLastPolicyAPIViolatedWarningOnly.containsKey(idPolicy)){
  335.                     this.inMemoryLastPolicyAPIViolatedWarningOnly.put(idPolicy, new DatiEventoGenerico());
  336.                 }
  337.                 if(!this.dbLastPolicyAPIViolatedWarningOnly.containsKey(idPolicy)){
  338.                     this.dbLastPolicyAPIViolatedWarningOnly.put(idPolicy, new DatabaseDatiEventoGenerico());
  339.                 }
  340.                 DatiEventoGenerico inMemoryLastPolicyAPIViolatedWarningOnlyPolicy = this.inMemoryLastPolicyAPIViolatedWarningOnly.get(idPolicy);
  341.                 
  342.                 if(inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.datiConsumatiThread){
  343.                     if(date==null)
  344.                         inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.data = DateManager.getDate();
  345.                     else
  346.                         inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.data = date;
  347.                     inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.descrizione = descrizione;
  348.                     inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.configurazione = configurazione;
  349.                     /**System.out.println("@@LOG AGGIORNO DATA POLICY VIOLAZIONE WARNING_ONLY ["+
  350.                             newSimpleDateFormat().format(inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.data)+"]");*/
  351.                     inMemoryLastPolicyAPIViolatedWarningOnlyPolicy.datiConsumatiThread=false;
  352.                 }
  353.             }finally {
  354.                 lock.release(slock, "log_"+evento.name());
  355.             }
  356.             break;
  357.         }
  358.         case TIMEOUT_CONNESSIONE:{
  359.             if(idPolicy==null){
  360.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  361.             }
  362.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  363.             try {
  364.                 if(!this.inMemoryLastTimeoutConnessione.containsKey(idPolicy)){
  365.                     this.inMemoryLastTimeoutConnessione.put(idPolicy, new DatiEventoGenerico());
  366.                 }
  367.                 if(!this.dbLastTimeoutConnessione.containsKey(idPolicy)){
  368.                     this.dbLastTimeoutConnessione.put(idPolicy, new DatabaseDatiEventoGenerico());
  369.                 }
  370.                 DatiEventoGenerico inMemoryLastTimeoutConnessioneRead = this.inMemoryLastTimeoutConnessione.get(idPolicy);
  371.                 
  372.                 if(inMemoryLastTimeoutConnessioneRead.datiConsumatiThread){
  373.                     if(date==null)
  374.                         inMemoryLastTimeoutConnessioneRead.data = DateManager.getDate();
  375.                     else
  376.                         inMemoryLastTimeoutConnessioneRead.data = date;
  377.                     inMemoryLastTimeoutConnessioneRead.descrizione = descrizione;
  378.                     inMemoryLastTimeoutConnessioneRead.configurazione = configurazione;
  379.                     /**System.out.println("@@LOG AGGIORNO DATA TIMEOUT CONNESSIONE VIOLAZIONE ["+
  380.                             newSimpleDateFormat().format(inMemoryLastTimeoutConnessioneRead.data)+"]");*/
  381.                     inMemoryLastTimeoutConnessioneRead.datiConsumatiThread=false;
  382.                 }
  383.             }finally {
  384.                 lock.release(slock, "log_"+evento.name());
  385.             }
  386.             break;
  387.         }
  388.         case TIMEOUT_RICHIESTA:{
  389.             if(idPolicy==null){
  390.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  391.             }
  392.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  393.             try {
  394.                 if(!this.inMemoryLastTimeoutRichiesta.containsKey(idPolicy)){
  395.                     this.inMemoryLastTimeoutRichiesta.put(idPolicy, new DatiEventoGenerico());
  396.                 }
  397.                 if(!this.dbLastTimeoutRichiesta.containsKey(idPolicy)){
  398.                     this.dbLastTimeoutRichiesta.put(idPolicy, new DatabaseDatiEventoGenerico());
  399.                 }
  400.                 DatiEventoGenerico inMemoryLastTimeoutRichiestaRead = this.inMemoryLastTimeoutRichiesta.get(idPolicy);
  401.                 
  402.                 if(inMemoryLastTimeoutRichiestaRead.datiConsumatiThread){
  403.                     if(date==null)
  404.                         inMemoryLastTimeoutRichiestaRead.data = DateManager.getDate();
  405.                     else
  406.                         inMemoryLastTimeoutRichiestaRead.data = date;
  407.                     inMemoryLastTimeoutRichiestaRead.descrizione = descrizione;
  408.                     inMemoryLastTimeoutRichiestaRead.configurazione = configurazione;
  409.                     /**System.out.println("@@LOG AGGIORNO DATA TIMEOUT RICHIESTA VIOLAZIONE ["+
  410.                             newSimpleDateFormat().format(inMemoryLastTimeoutRichiestaRead.data)+"]");*/
  411.                     inMemoryLastTimeoutRichiestaRead.datiConsumatiThread=false;
  412.                 }
  413.             }finally {
  414.                 lock.release(slock, "log_"+evento.name());
  415.             }
  416.             break;
  417.         }
  418.         case TIMEOUT_RISPOSTA:{
  419.             if(idPolicy==null){
  420.                 throw new CoreException(ID_POLICY_NON_FORNITA);
  421.             }
  422.             SemaphoreLock slock = lock.acquire("log_"+evento.name());
  423.             try {
  424.                 if(!this.inMemoryLastTimeoutRisposta.containsKey(idPolicy)){
  425.                     this.inMemoryLastTimeoutRisposta.put(idPolicy, new DatiEventoGenerico());
  426.                 }
  427.                 if(!this.dbLastTimeoutRisposta.containsKey(idPolicy)){
  428.                     this.dbLastTimeoutRisposta.put(idPolicy, new DatabaseDatiEventoGenerico());
  429.                 }
  430.                 DatiEventoGenerico inMemoryLastTimeoutRispostaRead = this.inMemoryLastTimeoutRisposta.get(idPolicy);
  431.                 
  432.                 if(inMemoryLastTimeoutRispostaRead.datiConsumatiThread){
  433.                     if(date==null)
  434.                         inMemoryLastTimeoutRispostaRead.data = DateManager.getDate();
  435.                     else
  436.                         inMemoryLastTimeoutRispostaRead.data = date;
  437.                     inMemoryLastTimeoutRispostaRead.descrizione = descrizione;
  438.                     inMemoryLastTimeoutRispostaRead.configurazione = configurazione;
  439.                     /**System.out.println("@@LOG AGGIORNO DATA TIMEOUT RISPOSTA VIOLAZIONE ["+
  440.                             newSimpleDateFormat().format(inMemoryLastTimeoutRispostaRead.data)+"]");*/
  441.                     inMemoryLastTimeoutRispostaRead.datiConsumatiThread=false;
  442.                 }
  443.             }finally {
  444.                 lock.release(slock, "log_"+evento.name());
  445.             }
  446.             break;
  447.         }


  450.         default:
  451.             throw new CoreException("Tipo di evento ["+evento.name()+"] non gestito con questo metodo");
  452.         }
  453.     }
  454.     
  455.     
  456.     private static void logInfo(Logger log,boolean debug,String msg){
  457.         if(debug){
  458.             log.info(msg);
  459.         }
  460.     }
  461.     private static void logDebug(Logger log,boolean debug,String msg){
  462.         if(debug){
  463.             log.debug(msg);
  464.         }
  465.     }
  466.     
  467.     private static final String SUFFIX_IN_CORSO_PARENTESI_QUADRE = "] ...";
  468.     private static final String SUFFIX_IN_CORSO = ") ...";
  469.     private static final String SUFFIX_WARNING_ONLY_IN_CORSO = ") (warning-only) ...";
  470.     private static final String SUFFIX_TERMINATA = ") terminata";
  471.     private static final String SUFFIX_WARNING_ONLY_TERMINATA = ") (warning-only) terminata";
  472.     private static final String EVERY = " every:";
  473.     private static final String SEPARATOR = "=================================================================================";
  474.     
  475.     private static String getSuffixDate(SimpleDateFormat df, Date newInterval, int secondi) {
  476.         return "[next-interval: "+df.format(newInterval)+
  477.             "] [Prossimo Controllo previsto tra "+secondi+" secondi: "+df.format(new Date(DateManager.getTimeMillis()+(secondi*1000)))+"]";
  478.     }
  479.         
  480.     public Date process(Logger log, int secondi, Date lastInterval, Connection connection, boolean debug) throws UtilsException{
  481.         
  482.         SimpleDateFormat df = DateUtils.getSimpleDateFormatMs();
  483.         
  484.         logInfo(log,debug,SEPARATOR);
  485.         
  486.         logInfo(log,debug,"Analisi memoria per generazione eventi in corso [interval: "+df.format(lastInterval)+SUFFIX_IN_CORSO_PARENTESI_QUADRE);
  487.                 
  488.         // Raccolgo informazioni in memoria per rilasciare il lock
  489.         
  490.         // TH_*
  491.         DatiEventoGenerico localInMemoryLastMaxRequests = null;
  492.         DatiEventoGenerico localInMemoryLastMaxRequestsWarningOnly = null;
  493.         DatiEventoGenerico localInMemoryLastPddCongestionata = null;
  494.         Map<String, DatiEventoGenerico> localInMemoryLastPolicyGlobaliViolated = new HashMap<>();
  495.         Map<String, DatiEventoGenerico> localInMemoryLastPolicyGlobaliViolatedWarningOnly = new HashMap<>();    
  496.         Map<String, DatiEventoGenerico> localInMemoryLastPolicyAPIViolated = new HashMap<>();
  497.         Map<String, DatiEventoGenerico> localInMemoryLastPolicyAPIViolatedWarningOnly = new HashMap<>();
  498.         Date newInterval = null;
  499.         SemaphoreLock slock = lock.acquire("process");
  500.         try {
  501.             
  502.             localInMemoryLastMaxRequests = this.inMemoryLastMaxRequests.readAndConsume();
  503.             localInMemoryLastMaxRequestsWarningOnly = this.inMemoryLastMaxRequestsWarningOnly.readAndConsume();
  504.             localInMemoryLastPddCongestionata = this.inMemoryLastPddCongestionata.readAndConsume();
  505.             
  506.             if(this.inMemoryLastPolicyGlobaliViolated!=null && this.inMemoryLastPolicyGlobaliViolated.size()>0){
  507.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyGlobaliViolated.entrySet()) {
  508.                     localInMemoryLastPolicyGlobaliViolated.put(entry.getKey(), entry.getValue().readAndConsume());
  509.                 }
  510.             }
  511.             if(this.inMemoryLastPolicyGlobaliViolatedWarningOnly!=null && this.inMemoryLastPolicyGlobaliViolatedWarningOnly.size()>0){
  512.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyGlobaliViolatedWarningOnly.entrySet()) {
  513.                     localInMemoryLastPolicyGlobaliViolatedWarningOnly.put(entry.getKey(), entry.getValue().readAndConsume());
  514.                 }
  515.             }
  516.             
  517.             if(this.inMemoryLastPolicyAPIViolated!=null && this.inMemoryLastPolicyAPIViolated.size()>0){
  518.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyAPIViolated.entrySet()) {
  519.                     localInMemoryLastPolicyAPIViolated.put(entry.getKey(), entry.getValue().readAndConsume());
  520.                 }
  521.             }
  522.             if(this.inMemoryLastPolicyAPIViolatedWarningOnly!=null && this.inMemoryLastPolicyAPIViolatedWarningOnly.size()>0){
  523.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyAPIViolatedWarningOnly.entrySet()) {
  524.                     localInMemoryLastPolicyAPIViolatedWarningOnly.put(entry.getKey(), entry.getValue().readAndConsume());
  525.                 }
  526.             }

  528.             newInterval = DateManager.getDate();
  529.         }finally {
  530.             lock.release(slock, "process");
  531.         }

  533.         
  534.         // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized
  535.         
  536.         // DB_*
  537.         DatabaseDatiEventoGenerico localDbLastMaxRequests = null;
  538.         DatabaseDatiEventoGenerico localDbLastMaxRequestsWarningOnly = null;
  539.         DatabaseDatiEventoGenerico localDbLastPddCongestionata = null;
  540.         Map<String, DatabaseDatiEventoGenerico> localDbLastPolicyGlobaliViolated = null;
  541.         Map<String, DatabaseDatiEventoGenerico> localDbLastPolicyGlobaliViolatedWarningOnly = null;
  542.         Map<String, DatabaseDatiEventoGenerico> localDbLastPolicyAPIViolated = null;
  543.         Map<String, DatabaseDatiEventoGenerico> localDbLastPolicyAPIViolatedWarningOnly = null;
  544.         localDbLastMaxRequests = this.dbLastMaxRequests;
  545.         localDbLastMaxRequestsWarningOnly = this.dbLastMaxRequestsWarningOnly;
  546.         localDbLastPddCongestionata = this.dbLastPddCongestionata;
  547.         localDbLastPolicyGlobaliViolated = this.dbLastPolicyGlobaliViolated;
  548.         localDbLastPolicyGlobaliViolatedWarningOnly = this.dbLastPolicyGlobaliViolatedWarningOnly;
  549.         localDbLastPolicyAPIViolated = this.dbLastPolicyAPIViolated;
  550.         localDbLastPolicyAPIViolatedWarningOnly = this.dbLastPolicyAPIViolatedWarningOnly;

  552.         
  553.         // Procedo ad effettuare l'elaborazione per emettere degli eventi
  554.         
  555.         logDebug(log,debug,"1. Analisi violazioni numero massimo richieste simultanee ...");
  556.         processSingleEvent(log, 
  557.                 localInMemoryLastMaxRequests, 
  558.                 localDbLastMaxRequests, 
  559.                 this.dbLastMaxRequests, 
  560.                 TipoEvento.CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE,
  561.                 CodiceEventoControlloTraffico.VIOLAZIONE, 
  562.                 CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  563.                 lastInterval, connection, this.gestoreEventi,
  564.                 null, debug);
  565.         logDebug(log,debug,"1. Analisi violazioni numero massimo richieste simultanee terminata");
  566.         
  567.         logDebug(log,debug,"2. Analisi violazioni numero massimo richieste simultanee (warning-only) ...");
  568.         processSingleEvent(log, 
  569.                 localInMemoryLastMaxRequestsWarningOnly, 
  570.                 localDbLastMaxRequestsWarningOnly, 
  571.                 this.dbLastMaxRequestsWarningOnly, 
  572.                 TipoEvento.CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE,
  573.                 CodiceEventoControlloTraffico.VIOLAZIONE_WARNING_ONLY, 
  574.                 CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA_WARNING_ONLY, 
  575.                 lastInterval, connection, this.gestoreEventi,
  576.                 null, debug);
  577.         logDebug(log,debug,"2. Analisi violazioni numero massimo richieste simultanee (warning-only) terminata");
  578.         
  579.         logDebug(log,debug,"3. Analisi controllo della congestione ...");
  580.         processSingleEvent(log, 
  581.                 localInMemoryLastPddCongestionata, 
  582.                 localDbLastPddCongestionata, 
  583.                 this.dbLastPddCongestionata, 
  584.                 TipoEvento.CONTROLLO_TRAFFICO_SOGLIA_CONGESTIONE,
  585.                 CodiceEventoControlloTraffico.VIOLAZIONE, 
  586.                 CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  587.                 lastInterval, connection, this.gestoreEventi,
  588.                 null, debug);
  589.         logDebug(log,debug,"3. Analisi controllo della congestione terminata");
  590.                 
  591.         logDebug(log,debug,"4. Analisi policy globali violate (size:"+localInMemoryLastPolicyGlobaliViolated.size()+SUFFIX_IN_CORSO);
  592.         if(!localInMemoryLastPolicyGlobaliViolated.isEmpty()) {
  593.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastPolicyGlobaliViolated.entrySet()) {
  594.                 String idPolicy = entry.getKey();
  595.                 processSingleEvent(log, 
  596.                         localInMemoryLastPolicyGlobaliViolated.get(idPolicy), 
  597.                         localDbLastPolicyGlobaliViolated.get(idPolicy), 
  598.                         this.dbLastPolicyGlobaliViolated.get(idPolicy), 
  599.                         TipoEvento.RATE_LIMITING_POLICY_GLOBALE,
  600.                         CodiceEventoControlloTraffico.VIOLAZIONE, 
  601.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  602.                         lastInterval, connection, this.gestoreEventi,
  603.                         idPolicy,debug);
  604.             }
  605.         }
  606.         logDebug(log,debug,"4. Analisi policy globali violate (size:"+localInMemoryLastPolicyGlobaliViolated.size()+SUFFIX_TERMINATA);
  607.         
  608.         logDebug(log,debug,"5. Analisi policy globali violate (size:"+localInMemoryLastPolicyGlobaliViolatedWarningOnly.size()+SUFFIX_WARNING_ONLY_IN_CORSO);
  609.         if(!localInMemoryLastPolicyGlobaliViolatedWarningOnly.isEmpty()) {
  610.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastPolicyGlobaliViolatedWarningOnly.entrySet()) {
  611.                 String idPolicy = entry.getKey();
  612.                 processSingleEvent(log, 
  613.                         localInMemoryLastPolicyGlobaliViolatedWarningOnly.get(idPolicy), 
  614.                         localDbLastPolicyGlobaliViolatedWarningOnly.get(idPolicy), 
  615.                         this.dbLastPolicyGlobaliViolatedWarningOnly.get(idPolicy), 
  616.                         TipoEvento.RATE_LIMITING_POLICY_GLOBALE,
  617.                         CodiceEventoControlloTraffico.VIOLAZIONE_WARNING_ONLY, 
  618.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA_WARNING_ONLY, 
  619.                         lastInterval, connection, this.gestoreEventi,
  620.                         idPolicy,debug);
  621.             }
  622.         }
  623.         logDebug(log,debug,"5. Analisi policy globali violate (size:"+localInMemoryLastPolicyGlobaliViolatedWarningOnly.size()+SUFFIX_WARNING_ONLY_TERMINATA);
  624.         
  625.         logDebug(log,debug,"6. Analisi policy API violate (size:"+localInMemoryLastPolicyAPIViolated.size()+SUFFIX_IN_CORSO);
  626.         if(!localInMemoryLastPolicyAPIViolated.isEmpty()) {
  627.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastPolicyAPIViolated.entrySet()) {
  628.                 String idPolicy = entry.getKey();
  629.                 processSingleEvent(log, 
  630.                         localInMemoryLastPolicyAPIViolated.get(idPolicy), 
  631.                         localDbLastPolicyAPIViolated.get(idPolicy), 
  632.                         this.dbLastPolicyAPIViolated.get(idPolicy), 
  633.                         TipoEvento.RATE_LIMITING_POLICY_API,
  634.                         CodiceEventoControlloTraffico.VIOLAZIONE, 
  635.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  636.                         lastInterval, connection, this.gestoreEventi,
  637.                         idPolicy,debug);    
  638.             }
  639.         }
  640.         logDebug(log,debug,"6. Analisi policy API violate (size:"+localInMemoryLastPolicyAPIViolated.size()+SUFFIX_TERMINATA);
  641.         
  642.         logDebug(log,debug,"7. Analisi policy API violate (size:"+localInMemoryLastPolicyAPIViolatedWarningOnly.size()+SUFFIX_WARNING_ONLY_IN_CORSO);
  643.         if(!localInMemoryLastPolicyAPIViolatedWarningOnly.isEmpty()) {
  644.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastPolicyAPIViolatedWarningOnly.entrySet()) {
  645.                 String idPolicy = entry.getKey();
  646.                 processSingleEvent(log, 
  647.                         localInMemoryLastPolicyAPIViolatedWarningOnly.get(idPolicy), 
  648.                         localDbLastPolicyAPIViolatedWarningOnly.get(idPolicy), 
  649.                         this.dbLastPolicyAPIViolatedWarningOnly.get(idPolicy), 
  650.                         TipoEvento.RATE_LIMITING_POLICY_API,
  651.                         CodiceEventoControlloTraffico.VIOLAZIONE_WARNING_ONLY, 
  652.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA_WARNING_ONLY, 
  653.                         lastInterval, connection, this.gestoreEventi,
  654.                         idPolicy,debug);    
  655.             }
  656.         }
  657.         logDebug(log,debug,"7. Analisi policy API violate (size:"+localInMemoryLastPolicyAPIViolatedWarningOnly.size()+SUFFIX_WARNING_ONLY_TERMINATA);
  658.         

  660.         logInfo(log,debug,"Analisi memoria per generazione eventi terminata "+getSuffixDate(df, newInterval, secondi));
  661.         
  662.         return newInterval; // da usare per il prossimo intervallo
  663.     }
  664.     public Date processConnectionTimeout(Logger log, int secondi, Date lastInterval, Connection connection, boolean debug) throws UtilsException{
  665.         
  666.         SimpleDateFormat df = DateUtils.getSimpleDateFormatMs();
  667.         
  668.         logInfo(log,debug,SEPARATOR);
  669.         
  670.         logInfo(log,debug,"Analisi memoria per generazione eventi in corso 'ConnectionTimeout' [interval: "+df.format(lastInterval)+SUFFIX_IN_CORSO_PARENTESI_QUADRE);
  671.                 
  672.         // Raccolgo informazioni in memoria per rilasciare il lock
  673.         
  674.         // TH_*
  675.         Map<String, DatiEventoGenerico> localInMemoryLastTimeoutConnessione = new HashMap<>();
  676.         Date newInterval = null;
  677.         SemaphoreLock slock = lock.acquire("processConnectionTimeout");
  678.         try {
  679.             if(this.inMemoryLastTimeoutConnessione!=null && this.inMemoryLastTimeoutConnessione.size()>0){
  680.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutConnessione.entrySet()) {
  681.                     localInMemoryLastTimeoutConnessione.put(entry.getKey(), entry.getValue().readAndConsume());
  682.                 }
  683.             }

  685.             newInterval = DateManager.getDate();
  686.         }finally {
  687.             lock.release(slock, "processConnectionTimeout");
  688.         }

  690.         
  691.         // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized
  692.         
  693.         // DB_*
  694.         Map<String, DatabaseDatiEventoGenerico> localDbLastTimeoutConnessione = null;
  695.         localDbLastTimeoutConnessione = this.dbLastTimeoutConnessione;

  697.         
  698.         // Procedo ad effettuare l'elaborazione per emettere degli eventi
  699.         
  700.         logDebug(log,debug,"8. Analisi eventi di Timeout durante la connessione (size:"+localInMemoryLastTimeoutConnessione.size()+SUFFIX_IN_CORSO);
  701.         if(!localInMemoryLastTimeoutConnessione.isEmpty()) {
  702.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastTimeoutConnessione.entrySet()) {
  703.                 String idPolicy = entry.getKey();
  704.                 processSingleEvent(log, 
  705.                         localInMemoryLastTimeoutConnessione.get(idPolicy), 
  706.                         localDbLastTimeoutConnessione.get(idPolicy), 
  707.                         this.dbLastTimeoutConnessione.get(idPolicy), 
  708.                         TipoEvento.CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT,
  709.                         CodiceEventoControlloTraffico.VIOLAZIONE, 
  710.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  711.                         lastInterval, connection, this.gestoreEventi,
  712.                         idPolicy,debug);    
  713.             }
  714.         }
  715.         logDebug(log,debug,"8. Analisi eventi di Timeout durante la connessione (size:"+localInMemoryLastTimeoutConnessione.size()+SUFFIX_TERMINATA);
  716.         
  717.         logInfo(log,debug,"Analisi memoria per generazione eventi terminata 'ConnectionTimeout' "+getSuffixDate(df, newInterval, secondi));
  718.         
  719.         return newInterval; // da usare per il prossimo intervallo
  720.     }
  721.     public void emitProcessConnectionTimeoutSkip(Logger log, boolean debug, int offsetConnectionTimeoutEveryXTimes, int checkConnectionTimeoutEveryXTimes) {
  722.         logDebug(log,debug,"8. Analisi eventi di Timeout durante la connessione non abilitata in questa iterazione (offset: "+offsetConnectionTimeoutEveryXTimes+EVERY+checkConnectionTimeoutEveryXTimes+")");
  723.     }
  724.     public Date processRequestReadTimeout(Logger log, int secondi, Date lastInterval, Connection connection, boolean debug) throws UtilsException{
  725.         
  726.         SimpleDateFormat df = DateUtils.getSimpleDateFormatMs();
  727.         
  728.         logInfo(log,debug,SEPARATOR);
  729.         
  730.         logInfo(log,debug,"Analisi memoria per generazione eventi in corso 'RequestReadTimeout' [interval: "+df.format(lastInterval)+SUFFIX_IN_CORSO_PARENTESI_QUADRE);
  731.                 
  732.         // Raccolgo informazioni in memoria per rilasciare il lock
  733.         
  734.         // TH_*
  735.         Map<String, DatiEventoGenerico> localInMemoryLastTimeoutRichiesta = new HashMap<>();
  736.         Date newInterval = null;
  737.         SemaphoreLock slock = lock.acquire("processRequestReadTimeout");
  738.         try {
  739.             if(this.inMemoryLastTimeoutRichiesta!=null && this.inMemoryLastTimeoutRichiesta.size()>0){
  740.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutRichiesta.entrySet()) {
  741.                     localInMemoryLastTimeoutRichiesta.put(entry.getKey(), entry.getValue().readAndConsume());
  742.                 }
  743.             }

  745.             newInterval = DateManager.getDate();
  746.         }finally {
  747.             lock.release(slock, "processRequestReadTimeout");
  748.         }

  750.         
  751.         // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized
  752.         
  753.         // DB_*
  754.         Map<String, DatabaseDatiEventoGenerico> localDbLastTimeoutRichiesta = null;
  755.         localDbLastTimeoutRichiesta = this.dbLastTimeoutRichiesta;

  757.         
  758.         // Procedo ad effettuare l'elaborazione per emettere degli eventi
  759.                 
  760.         logDebug(log,debug,"9. Analisi eventi di Timeout durante la ricezione della richiesta (size:"+localInMemoryLastTimeoutRichiesta.size()+SUFFIX_IN_CORSO);
  761.         if(!localInMemoryLastTimeoutRichiesta.isEmpty()) {
  762.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastTimeoutRichiesta.entrySet()) {
  763.                 String idPolicy = entry.getKey();
  764.                 processSingleEvent(log, 
  765.                         localInMemoryLastTimeoutRichiesta.get(idPolicy), 
  766.                         localDbLastTimeoutRichiesta.get(idPolicy), 
  767.                         this.dbLastTimeoutRichiesta.get(idPolicy), 
  768.                         TipoEvento.CONTROLLO_TRAFFICO_REQUEST_READ_TIMEOUT,
  769.                         CodiceEventoControlloTraffico.VIOLAZIONE, 
  770.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  771.                         lastInterval, connection, this.gestoreEventi,
  772.                         idPolicy,debug);    
  773.             }
  774.         }
  775.         logDebug(log,debug,"9. Analisi eventi di Timeout durante la ricezione della richiesta (size:"+localInMemoryLastTimeoutRichiesta.size()+SUFFIX_TERMINATA);
  776.         
  777.         logInfo(log,debug,"Analisi memoria per generazione eventi terminata 'RequestReadTimeout' "+getSuffixDate(df, newInterval, secondi));
  778.         
  779.         return newInterval; // da usare per il prossimo intervallo
  780.     }
  781.     public void emitProcessRequestReadTimeoutSkip(Logger log, boolean debug, int offsetRequestReadTimeoutEveryXTimes, int checkRequestReadTimeoutEveryXTimes) {
  782.         logDebug(log,debug,"9. Analisi eventi di Timeout durante la ricezione della richiesta non abilitata in questa iterazione (offset: "+offsetRequestReadTimeoutEveryXTimes+EVERY+checkRequestReadTimeoutEveryXTimes+")");
  783.     }
  784.     public Date processReadTimeout(Logger log, int secondi, Date lastInterval, Connection connection, boolean debug) throws UtilsException{
  785.         
  786.         SimpleDateFormat df = DateUtils.getSimpleDateFormatMs();
  787.         
  788.         logInfo(log,debug,SEPARATOR);
  789.         
  790.         logInfo(log,debug,"Analisi memoria per generazione eventi in corso 'ReadTimeout' [interval: "+df.format(lastInterval)+SUFFIX_IN_CORSO_PARENTESI_QUADRE);
  791.                 
  792.         // Raccolgo informazioni in memoria per rilasciare il lock
  793.         
  794.         // TH_*
  795.         Map<String, DatiEventoGenerico> localInMemoryLastTimeoutRisposta = new HashMap<>();
  796.         Date newInterval = null;
  797.         SemaphoreLock slock = lock.acquire("processReadTimeout");
  798.         try {
  799.             if(this.inMemoryLastTimeoutRisposta!=null && this.inMemoryLastTimeoutRisposta.size()>0){
  800.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutRisposta.entrySet()) {
  801.                     localInMemoryLastTimeoutRisposta.put(entry.getKey(), entry.getValue().readAndConsume());
  802.                 }
  803.             }

  805.             newInterval = DateManager.getDate();
  806.         }finally {
  807.             lock.release(slock, "processReadTimeout");
  808.         }

  810.         
  811.         // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized
  812.         
  813.         // DB_*
  814.         Map<String, DatabaseDatiEventoGenerico> localDbLastTimeoutRisposta = null;
  815.         localDbLastTimeoutRisposta = this.dbLastTimeoutRisposta;

  817.         
  818.         // Procedo ad effettuare l'elaborazione per emettere degli eventi
  819.         
  820.         logDebug(log,debug,"10. Analisi eventi di Timeout durante la ricezione della risposta (size:"+localInMemoryLastTimeoutRisposta.size()+SUFFIX_IN_CORSO);
  821.         if(!localInMemoryLastTimeoutRisposta.isEmpty()) {
  822.             for (Map.Entry<String,DatiEventoGenerico> entry : localInMemoryLastTimeoutRisposta.entrySet()) {
  823.                 String idPolicy = entry.getKey();
  824.                 processSingleEvent(log, 
  825.                         localInMemoryLastTimeoutRisposta.get(idPolicy), 
  826.                         localDbLastTimeoutRisposta.get(idPolicy), 
  827.                         this.dbLastTimeoutRisposta.get(idPolicy), 
  828.                         TipoEvento.CONTROLLO_TRAFFICO_READ_TIMEOUT,
  829.                         CodiceEventoControlloTraffico.VIOLAZIONE, 
  830.                         CodiceEventoControlloTraffico.VIOLAZIONE_RISOLTA, 
  831.                         lastInterval, connection, this.gestoreEventi,
  832.                         idPolicy,debug);    
  833.             }
  834.         }
  835.         logDebug(log,debug,"10. Analisi eventi di Timeout durante la ricezione della risposta (size:"+localInMemoryLastTimeoutRisposta.size()+SUFFIX_TERMINATA);

  837.         
  838.         logInfo(log,debug,"Analisi memoria per generazione eventi terminata 'ReadTimeout' "+getSuffixDate(df, newInterval, secondi));
  839.         
  840.         return newInterval; // da usare per il prossimo intervallo
  841.     }
  842.     public void emitProcessReadTimeoutSkip(Logger log, boolean debug, int offsetReadTimeoutEveryXTimes, int checkReadTimeoutEveryXTimes) {
  843.         logDebug(log,debug,"10. Analisi eventi di Timeout durante la ricezione della risposta non abilitata in questa iterazione (offset: "+offsetReadTimeoutEveryXTimes+EVERY+checkReadTimeoutEveryXTimes+")");
  844.     }
  845.     
  846.     
  847.     private static void processSingleEvent(Logger log, DatiEventoGenerico localInMemory,DatabaseDatiEventoGenerico localDb,
  848.             DatabaseDatiEventoGenerico thisDb,
  849.             TipoEvento tipoEvento,
  850.             CodiceEventoControlloTraffico eventoViolazione, CodiceEventoControlloTraffico eventoViolazioneRisolta, 
  851.             Date lastInterval, Connection connection, GestoreEventi gestoreEventi,
  852.             String idPolicy, boolean debug) throws UtilsException {
  853.         
  854.         // Gestione violazione maxThreads
  855.         
  856.         boolean esisteTHultimoIntervallo = false;
  857.         if(localInMemory!=null && 
  858.                 localInMemory.data!=null && 
  859.                 localInMemory.data.after(lastInterval)){
  860.             esisteTHultimoIntervallo = true;
  861.         }
  862.         
  863.         if(localDb!=null && 
  864.                 localDb.data!=null){
  865.             logDebug(log,debug,"\tTH_ultimoIntervallo: "+esisteTHultimoIntervallo+
  866.                     " DB_last:"+(localDb!=null)+
  867.                     " DB_last.codiceEvento:"+localDb.codiceEvento.name());
  868.         }
  869.         else{
  870.             logDebug(log,debug,"\tTH_ultimoIntervallo: "+esisteTHultimoIntervallo);
  871.         }
  872.     
  873.         if(esisteTHultimoIntervallo){
  874.             if(localDb!=null && 
  875.                     localDb.data!=null){
  876.                 if(eventoViolazioneRisolta.equals(localDb.codiceEvento)){
  877.                     // sono ritornato dentro una violazione di stato
  878.                     CodiceEventoControlloTraffico codice = eventoViolazione;
  879.                     Evento evento = buildEvento(tipoEvento,codice, idPolicy,
  880.                             localInMemory.descrizione,
  881.                             localInMemory.configurazione,
  882.                             localInMemory.data); // uso come data dell'evento la data in cui e' accaduta la segnalazione
  883.                     logEvento(gestoreEventi, connection, evento, log, debug);
  884.                     /**synchronized (this.semaphore) { // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized*/
  885.                     thisDb.data = evento.getOraRegistrazione();
  886.                     thisDb.codiceEvento = codice;
  887.                     /**}*/
  888.                     if(idPolicy!=null)
  889.                         logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice, idPolicy));
  890.                     else
  891.                         logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice));
  892.                 }
  893.             }
  894.             else{
  895.                 // prima volta che succede il problema, emetto evento di violazione
  896.                 CodiceEventoControlloTraffico codice = eventoViolazione;
  897.                 Evento evento = buildEvento(tipoEvento,codice, idPolicy,
  898.                         localInMemory.descrizione,
  899.                         localInMemory.configurazione,
  900.                         localInMemory.data); // uso come data dell'evento la data in cui e' accaduta la segnalazione
  901.                 logEvento(gestoreEventi, connection, evento, log, debug);
  902.                 /** synchronized (this.semaphore) { // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized*/
  903.                 thisDb.data = evento.getOraRegistrazione();
  904.                 thisDb.codiceEvento = codice;
  905.                 if(idPolicy!=null)
  906.                     logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice, idPolicy));
  907.                 else
  908.                     logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice));
  909.                 /**}*/
  910.             }
  911.         }
  912.         else{
  913.             if(localDb!=null && 
  914.                     localDb.data!=null &&
  915.                 eventoViolazione.equals(localDb.codiceEvento)){
  916.                 // emetto evento che non risulta piu' violato.
  917.                 CodiceEventoControlloTraffico codice = eventoViolazioneRisolta;
  918.                 Evento evento = buildEvento(tipoEvento,codice, idPolicy,
  919.                         localDb.descrizione, 
  920.                         localInMemory!=null && localInMemory.configurazione!=null ? localInMemory.configurazione : localDb.configurazione, // importante per far arrivare la configurazione usata nella gestione delle policy
  921.                         DateManager.getDate());
  922.                 logEvento(gestoreEventi, connection, evento, log, debug);
  923.                 /** synchronized (this.semaphore) { // Gli eventi db_* sono acceduti solo dal thread non serve un synchronized*/
  924.                 thisDb.data = evento.getOraRegistrazione();
  925.                 thisDb.codiceEvento = codice;
  926.                 if(idPolicy!=null)
  927.                     logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice, idPolicy));
  928.                 else
  929.                     logDebug(log,debug,getProcessSingleEventMessage(tipoEvento, codice));
  930.                 /**}*/
  931.             }
  932.         }

  934.     }
  935.     
  936.     private static String getProcessSingleEventMessage(TipoEvento tipoEvento, CodiceEventoControlloTraffico codice, String idPolicy) {
  937.         return "\tEmetto Evento tipo["+tipoEvento+"] codice["+codice+"_"+idPolicy+"]";
  938.     }
  939.     private static String getProcessSingleEventMessage(TipoEvento tipoEvento, CodiceEventoControlloTraffico codice) {
  940.         return "\tEmetto Evento tipo["+tipoEvento+"] codice["+codice+"]";
  941.     }
  942.     
  943.     private static Evento buildEvento(TipoEvento tipoEvento, CodiceEventoControlloTraffico codice, String idPolicy, String descrizione, String configurazione, Date data) throws UtilsException {
  944.         Evento evento = new Evento();
  945.         evento.setTipo(tipoEvento.getValue());
  946.         evento.setCodice(codice.getValue());
  947.         if(idPolicy!=null){
  948.             evento.setIdConfigurazione(idPolicy);
  949.         }       
  950.         evento.setDescrizione(descrizione);
  951.         evento.setConfigurazione(configurazione);
  952.         evento.setOraRegistrazione(data);
  953.         
  954.         switch (tipoEvento) {
  955.         case CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE:
  956.             switch (codice) {
  957.             case VIOLAZIONE:
  958.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.ERROR));
  959.                 break;
  960.             case VIOLAZIONE_RISOLTA:
  961.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  962.                 break;
  963.             case VIOLAZIONE_WARNING_ONLY:
  964.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.WARN));
  965.                 break;
  966.             case VIOLAZIONE_RISOLTA_WARNING_ONLY:
  967.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  968.                 break;
  969.             default:
  970.                 // altri casi non previsti per CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE
  971.                 break;
  972.             }
  973.             break;
  974.         case CONTROLLO_TRAFFICO_SOGLIA_CONGESTIONE:
  975.             switch (codice) {
  976.             case VIOLAZIONE:
  977.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.WARN));
  978.                 break;
  979.             case VIOLAZIONE_RISOLTA:
  980.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  981.                 break;
  982.             default:
  983.                 // altri casi non previsti per CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE
  984.                 break;
  985.             }
  986.             break;
  987.         case RATE_LIMITING_POLICY_GLOBALE:
  988.         case RATE_LIMITING_POLICY_API:
  989.             switch (codice) {
  990.             case VIOLAZIONE:
  991.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.ERROR));
  992.                 break;
  993.             case VIOLAZIONE_RISOLTA:
  994.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  995.                 break;
  996.             case VIOLAZIONE_WARNING_ONLY:
  997.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.WARN));
  998.                 break;
  999.             case VIOLAZIONE_RISOLTA_WARNING_ONLY:
  1000.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  1001.                 break;
  1002.             }
  1003.             break;
  1004.         case CONTROLLO_TRAFFICO_CONNECTION_TIMEOUT:
  1005.         case CONTROLLO_TRAFFICO_REQUEST_READ_TIMEOUT:
  1006.         case CONTROLLO_TRAFFICO_READ_TIMEOUT:
  1007.             switch (codice) {
  1008.             case VIOLAZIONE:
  1009.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.ERROR));
  1010.                 break;
  1011.             case VIOLAZIONE_RISOLTA:
  1012.                 evento.setSeverita(SeveritaConverter.toIntValue(TipoSeverita.INFO));
  1013.                 break;
  1014.             default:
  1015.                 // altri casi non previsti per CONTROLLO_TRAFFICO_READ_TIMEOUT
  1016.                 break;
  1017.             }
  1018.             break;
  1019.         default:
  1020.             // altri casi non previsti per questo notificatore eventi
  1021.             break;
  1022.         }
  1023.         
  1024.         evento.setClusterId(OpenSPCoop2Properties.getInstance().getClusterId(false));
  1025.         return evento;
  1026.     }
  1027.     
  1028.     private static void logEvento(GestoreEventi gestoreEventi, Connection connection, Evento evento, Logger log, boolean debug) throws UtilsException {
  1029.         
  1030.         // Fix evento per passarlo al notifier
  1031.         String configurazione = evento.getConfigurazione();
  1032.         if(PolicyUtilities.isConfigurazioneEventoPerPolicy(configurazione)) {
  1033.             evento.setConfigurazione(null); // serve solo per passarlo al notifier
  1034.         }
  1035.         
  1036.         try {
  1037.             gestoreEventi.log(evento, connection);
  1038.         }catch(Exception e) {
  1039.             throw new UtilsException(e.getMessage(),e);
  1040.         }
  1041.         
  1042.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  1043.         
  1044.         if(properties.isControlloTrafficoEnabled()) {
  1045.             
  1046.             ConfigurazioneGatewayControlloTraffico config = properties.getConfigurazioneControlloTraffico();
  1047.             if(config.isNotifierEnabled()) {
  1048.                 
  1049.                 INotify notifier = config.getNotifier();
  1050.                 if(notifier.isNotifichePassiveAttive()) {
  1051.                     TipoEvento tipoEvento = TipoEvento.toEnumConstant(evento.getTipo());
  1052.                     CodiceEventoControlloTraffico codiceEvento = CodiceEventoControlloTraffico.toEnumConstant(evento.getCodice());
  1053.                     switch (tipoEvento) {
  1054.                     case CONTROLLO_TRAFFICO_NUMERO_MASSIMO_RICHIESTE_SIMULTANEE:
  1055.                     case CONTROLLO_TRAFFICO_SOGLIA_CONGESTIONE:
  1056.                         notifier.updateStatoRilevamentoCongestione(log, debug, tipoEvento, codiceEvento, evento.getDescrizione());
  1057.                         break;
  1058.                     case RATE_LIMITING_POLICY_GLOBALE:
  1059.                     case RATE_LIMITING_POLICY_API:
  1060.                         notifier.updateStatoRilevamentoViolazionePolicy(log, debug, tipoEvento, codiceEvento, evento.getIdConfigurazione(), configurazione);
  1061.                         break;
  1062.                     case CONTROLLO_TRAFFICO_REQUEST_READ_TIMEOUT:
  1063.                         notifier.updateStatoRilevamentoRequestReadTimeout(log, debug, tipoEvento, codiceEvento, evento.getIdConfigurazione(), configurazione);
  1064.                         break;
  1065.                     case CONTROLLO_TRAFFICO_READ_TIMEOUT:
  1066.                         notifier.updateStatoRilevamentoReadTimeout(log, debug, tipoEvento, codiceEvento, evento.getIdConfigurazione(), configurazione);
  1067.                         break;
  1068.                     default:
  1069.                         // altri casi non previsti per questo notificatore eventi
  1070.                         break;
  1071.                     }
  1072.                 }
  1073.             }
  1074.             
  1075.         }
  1076.         
  1077.     }

  1079.     
  1080.     

  1082.     //---- Per salvare

  1084.     private static final String ZIP_IN_MEMORY = "memory";
  1085.     private static final String ZIP_DB = "db";
  1086.     private static final String ZIP_LAST_MAX_REQUESTS = "lastMaxRequests.xml";
  1087.     private static final String ZIP_LAST_MAX_REQUESTS_WARNING_ONLY = "lastMaxRequests_warningOnly.xml";
  1088.     private static final String ZIP_LAST_PDD_CONGESTIONATA = "lastPddCongestionata.xml";
  1089.     private static final String ZIP_POLICY_GLOBALE = "policyGlobale";
  1090.     private static final String ZIP_POLICY_GLOBALE_WARNING_ONLY = "policyGlobale_warningOnly";
  1091.     private static final String ZIP_POLICY_API = "policyAPI";
  1092.     private static final String ZIP_POLICY_API_WARNING_ONLY = "policyAPI_warningOnly";
  1093.     private static final String ZIP_EVENTO_TIMEOUT_CONNESSIONE = "connectionTimeout";
  1094.     private static final String ZIP_EVENTO_TIMEOUT_RICHIESTA = "requestReadTimeout";
  1095.     private static final String ZIP_EVENTO_TIMEOUT_RISPOSTA = "readTimeout";

  1097.     
  1098.     public void serialize(File file) throws UtilsException{
  1099.         try (FileOutputStream out = new FileOutputStream(file, false);){ // se già esiste lo sovrascrive
  1100.             this.serialize(out);
  1101.             out.flush();
  1102.         }
  1103.         catch(Exception e) {
  1104.             throw new UtilsException(e.getMessage(),e);
  1105.         }
  1106.     }
  1107.     
  1108.     @Deprecated
  1109.     // Il meccanismo non funzionava, non si riusciva a riottenere uno stato corretto
  1110.     public void serialize(OutputStream out) throws UtilsException{
  1111.             
  1112.         try (ZipOutputStream zipOut = new ZipOutputStream(out);){
  1113.             
  1114.             String rootPackageDir = "";
  1115.             // Il codice dopo fissa il problema di inserire una directory nel package.
  1116.             // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1117.             rootPackageDir = Costanti.OPENSPCOOP2_ARCHIVE_ROOT_DIR+File.separatorChar;
  1118.             
  1119.             
  1120.             // String inMemory Path
  1121.             String inMemoryDir = rootPackageDir + ZIP_IN_MEMORY + File.separatorChar;
  1122.             
  1123.             if(this.inMemoryLastMaxRequests!=null) {
  1124.                 zipOut.putNextEntry(new ZipEntry(inMemoryDir+ZIP_LAST_MAX_REQUESTS));
  1125.                 convertToDatiEventoGenericoSerializabled(this.inMemoryLastMaxRequests, "inMemory_lastMaxRequests").
  1126.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1127.             }
  1128.             
  1129.             if(this.inMemoryLastMaxRequestsWarningOnly!=null) {
  1130.                 zipOut.putNextEntry(new ZipEntry(inMemoryDir+ZIP_LAST_MAX_REQUESTS_WARNING_ONLY));
  1131.                 convertToDatiEventoGenericoSerializabled(this.inMemoryLastMaxRequestsWarningOnly, "inMemory_lastMaxRequests_warningOnly").
  1132.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1133.             }
  1134.             
  1135.             if(this.inMemoryLastPddCongestionata!=null) {
  1136.                 zipOut.putNextEntry(new ZipEntry(inMemoryDir+ZIP_LAST_PDD_CONGESTIONATA));
  1137.                 convertToDatiEventoGenericoSerializabled(this.inMemoryLastPddCongestionata, "inMemory_lastPddCongestionata").
  1138.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1139.             }
  1140.             
  1141.             if(this.inMemoryLastPolicyGlobaliViolated!=null && this.inMemoryLastPolicyGlobaliViolated.size()>0) {
  1142.                 int index = 1;
  1143.                 String inMemoryPolicyDir = inMemoryDir + ZIP_POLICY_GLOBALE + File.separatorChar;
  1144.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyGlobaliViolated.entrySet()) {
  1145.                     String idPolicy = entry.getKey();
  1146.                     DatiEventoGenerico evento = this.inMemoryLastPolicyGlobaliViolated.get(idPolicy);
  1147.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_POLICY_GLOBALE+"_"+index+".xml"));
  1148.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1149.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1150.                     index++;
  1151.                 }
  1152.             }
  1153.             
  1154.             if(this.inMemoryLastPolicyGlobaliViolatedWarningOnly!=null && this.inMemoryLastPolicyGlobaliViolatedWarningOnly.size()>0) {
  1155.                 int index = 1;
  1156.                 String inMemoryPolicyDir = inMemoryDir + ZIP_POLICY_GLOBALE_WARNING_ONLY + File.separatorChar;
  1157.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyGlobaliViolatedWarningOnly.entrySet()) {
  1158.                     String idPolicy = entry.getKey();
  1159.                     DatiEventoGenerico evento = this.inMemoryLastPolicyGlobaliViolatedWarningOnly.get(idPolicy);
  1160.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_POLICY_GLOBALE_WARNING_ONLY+"_"+index+".xml"));
  1161.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1162.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1163.                     index++;
  1164.                 }
  1165.             }
  1166.             
  1167.             if(this.inMemoryLastPolicyAPIViolated!=null && this.inMemoryLastPolicyAPIViolated.size()>0) {
  1168.                 int index = 1;
  1169.                 String inMemoryPolicyDir = inMemoryDir + ZIP_POLICY_API + File.separatorChar;
  1170.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyAPIViolated.entrySet()) {
  1171.                     String idPolicy = entry.getKey();
  1172.                     DatiEventoGenerico evento = this.inMemoryLastPolicyAPIViolated.get(idPolicy);
  1173.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_POLICY_API+"_"+index+".xml"));
  1174.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1175.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1176.                     index++;
  1177.                 }
  1178.             }
  1179.             
  1180.             if(this.inMemoryLastPolicyAPIViolatedWarningOnly!=null && this.inMemoryLastPolicyAPIViolatedWarningOnly.size()>0) {
  1181.                 int index = 1;
  1182.                 String inMemoryPolicyDir = inMemoryDir + ZIP_POLICY_API_WARNING_ONLY + File.separatorChar;
  1183.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastPolicyAPIViolatedWarningOnly.entrySet()) {
  1184.                     String idPolicy = entry.getKey();
  1185.                     DatiEventoGenerico evento = this.inMemoryLastPolicyAPIViolatedWarningOnly.get(idPolicy);
  1186.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_POLICY_API_WARNING_ONLY+"_"+index+".xml"));
  1187.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1188.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1189.                     index++;
  1190.                 }
  1191.             }
  1192.             
  1193.             if(this.inMemoryLastTimeoutConnessione!=null && this.inMemoryLastTimeoutConnessione.size()>0) {
  1194.                 int index = 1;
  1195.                 String inMemoryPolicyDir = inMemoryDir + ZIP_EVENTO_TIMEOUT_CONNESSIONE + File.separatorChar;
  1196.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutConnessione.entrySet()) {
  1197.                     String idPolicy = entry.getKey();
  1198.                     DatiEventoGenerico evento = this.inMemoryLastTimeoutConnessione.get(idPolicy);
  1199.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_EVENTO_TIMEOUT_CONNESSIONE+"_"+index+".xml"));
  1200.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1201.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1202.                     index++;
  1203.                 }
  1204.             }
  1205.             
  1206.             if(this.inMemoryLastTimeoutRichiesta!=null && this.inMemoryLastTimeoutRichiesta.size()>0) {
  1207.                 int index = 1;
  1208.                 String inMemoryPolicyDir = inMemoryDir + ZIP_EVENTO_TIMEOUT_RICHIESTA + File.separatorChar;
  1209.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutRichiesta.entrySet()) {
  1210.                     String idPolicy = entry.getKey();
  1211.                     DatiEventoGenerico evento = this.inMemoryLastTimeoutRichiesta.get(idPolicy);
  1212.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_EVENTO_TIMEOUT_RICHIESTA+"_"+index+".xml"));
  1213.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1214.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1215.                     index++;
  1216.                 }
  1217.             }
  1218.             
  1219.             if(this.inMemoryLastTimeoutRisposta!=null && this.inMemoryLastTimeoutRisposta.size()>0) {
  1220.                 int index = 1;
  1221.                 String inMemoryPolicyDir = inMemoryDir + ZIP_EVENTO_TIMEOUT_RISPOSTA + File.separatorChar;
  1222.                 for (Map.Entry<String,DatiEventoGenerico> entry : this.inMemoryLastTimeoutRisposta.entrySet()) {
  1223.                     String idPolicy = entry.getKey();
  1224.                     DatiEventoGenerico evento = this.inMemoryLastTimeoutRisposta.get(idPolicy);
  1225.                     zipOut.putNextEntry(new ZipEntry(inMemoryPolicyDir+ZIP_EVENTO_TIMEOUT_RISPOSTA+"_"+index+".xml"));
  1226.                     convertToDatiEventoGenericoSerializabled(evento, idPolicy).
  1227.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1228.                     index++;
  1229.                 }
  1230.             }
  1231.             
  1232.             
  1233.             // String db Path
  1234.             String dbDir = rootPackageDir + ZIP_DB + File.separatorChar;
  1235.             
  1236.             if(this.dbLastMaxRequests!=null) {
  1237.                 zipOut.putNextEntry(new ZipEntry(dbDir+ZIP_LAST_MAX_REQUESTS));
  1238.                 convertDBToDatiEventoGenericoSerializabled(this.dbLastMaxRequests, "db_lastMaxRequests").
  1239.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1240.             }
  1241.             
  1242.             if(this.dbLastMaxRequestsWarningOnly!=null) {
  1243.                 zipOut.putNextEntry(new ZipEntry(dbDir+ZIP_LAST_MAX_REQUESTS_WARNING_ONLY));
  1244.                 convertDBToDatiEventoGenericoSerializabled(this.dbLastMaxRequestsWarningOnly, "db_lastMaxRequests_warningOnly").
  1245.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1246.             }
  1247.             
  1248.             if(this.dbLastPddCongestionata!=null) {
  1249.                 zipOut.putNextEntry(new ZipEntry(dbDir+ZIP_LAST_PDD_CONGESTIONATA));
  1250.                 convertDBToDatiEventoGenericoSerializabled(this.dbLastPddCongestionata, "db_lastPddCongestionata").
  1251.                     writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1252.             }
  1253.             
  1254.             if(this.dbLastPolicyGlobaliViolated!=null && this.dbLastPolicyGlobaliViolated.size()>0) {
  1255.                 int index = 1;
  1256.                 String dbPolicyDir = dbDir + ZIP_POLICY_GLOBALE + File.separatorChar;
  1257.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastPolicyGlobaliViolated.entrySet()) {
  1258.                     String idPolicy = entry.getKey();
  1259.                     DatabaseDatiEventoGenerico evento = this.dbLastPolicyGlobaliViolated.get(idPolicy);
  1260.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_POLICY_GLOBALE+"_"+index+".xml"));
  1261.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1262.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1263.                     index++;
  1264.                 }
  1265.             }
  1266.             
  1267.             if(this.dbLastPolicyGlobaliViolatedWarningOnly!=null && this.dbLastPolicyGlobaliViolatedWarningOnly.size()>0) {
  1268.                 int index = 1;
  1269.                 String dbPolicyDir = dbDir + ZIP_POLICY_GLOBALE_WARNING_ONLY + File.separatorChar;
  1270.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastPolicyGlobaliViolatedWarningOnly.entrySet()) {
  1271.                     String idPolicy = entry.getKey();
  1272.                     DatabaseDatiEventoGenerico evento = this.dbLastPolicyGlobaliViolatedWarningOnly.get(idPolicy);
  1273.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_POLICY_GLOBALE_WARNING_ONLY+"_"+index+".xml"));
  1274.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1275.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1276.                     index++;
  1277.                 }
  1278.             }
  1279.             
  1280.             if(this.dbLastPolicyAPIViolated!=null && this.dbLastPolicyAPIViolated.size()>0) {
  1281.                 int index = 1;
  1282.                 String dbPolicyDir = dbDir + ZIP_POLICY_API + File.separatorChar;
  1283.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastPolicyAPIViolated.entrySet()) {
  1284.                     String idPolicy = entry.getKey();
  1285.                     DatabaseDatiEventoGenerico evento = this.dbLastPolicyAPIViolated.get(idPolicy);
  1286.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_POLICY_API+"_"+index+".xml"));
  1287.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1288.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1289.                     index++;
  1290.                 }
  1291.             }
  1292.             
  1293.             if(this.dbLastPolicyAPIViolatedWarningOnly!=null && this.dbLastPolicyAPIViolatedWarningOnly.size()>0) {
  1294.                 int index = 1;
  1295.                 String dbPolicyDir = dbDir + ZIP_POLICY_API_WARNING_ONLY + File.separatorChar;
  1296.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastPolicyAPIViolatedWarningOnly.entrySet()) {
  1297.                     String idPolicy = entry.getKey();
  1298.                     DatabaseDatiEventoGenerico evento = this.dbLastPolicyAPIViolatedWarningOnly.get(idPolicy);
  1299.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_POLICY_API_WARNING_ONLY+"_"+index+".xml"));
  1300.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1301.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1302.                     index++;
  1303.                 }
  1304.             }
  1305.             
  1306.             if(this.dbLastTimeoutConnessione!=null && this.dbLastTimeoutConnessione.size()>0) {
  1307.                 int index = 1;
  1308.                 String dbPolicyDir = dbDir + ZIP_EVENTO_TIMEOUT_CONNESSIONE + File.separatorChar;
  1309.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastTimeoutConnessione.entrySet()) {
  1310.                     String idPolicy = entry.getKey();
  1311.                     DatabaseDatiEventoGenerico evento = this.dbLastTimeoutConnessione.get(idPolicy);
  1312.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_EVENTO_TIMEOUT_CONNESSIONE+"_"+index+".xml"));
  1313.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1314.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1315.                     index++;
  1316.                 }
  1317.             }
  1318.             
  1319.             if(this.dbLastTimeoutRichiesta!=null && this.dbLastTimeoutRichiesta.size()>0) {
  1320.                 int index = 1;
  1321.                 String dbPolicyDir = dbDir + ZIP_EVENTO_TIMEOUT_RICHIESTA + File.separatorChar;
  1322.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastTimeoutRichiesta.entrySet()) {
  1323.                     String idPolicy = entry.getKey();
  1324.                     DatabaseDatiEventoGenerico evento = this.dbLastTimeoutRichiesta.get(idPolicy);
  1325.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_EVENTO_TIMEOUT_RICHIESTA+"_"+index+".xml"));
  1326.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1327.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1328.                     index++;
  1329.                 }
  1330.             }
  1331.             
  1332.             if(this.dbLastTimeoutRisposta!=null && this.dbLastTimeoutRisposta.size()>0) {
  1333.                 int index = 1;
  1334.                 String dbPolicyDir = dbDir + ZIP_EVENTO_TIMEOUT_RISPOSTA + File.separatorChar;
  1335.                 for (Map.Entry<String,DatabaseDatiEventoGenerico> entry : this.dbLastTimeoutRisposta.entrySet()) {
  1336.                     String idPolicy = entry.getKey();
  1337.                     DatabaseDatiEventoGenerico evento = this.dbLastTimeoutRisposta.get(idPolicy);
  1338.                     zipOut.putNextEntry(new ZipEntry(dbPolicyDir+ZIP_EVENTO_TIMEOUT_RISPOSTA+"_"+index+".xml"));
  1339.                     convertDBToDatiEventoGenericoSerializabled(evento, idPolicy).
  1340.                         writeTo(zipOut, WriteToSerializerType.XML_JAXB);
  1341.                     index++;
  1342.                 }
  1343.             }
  1344.         
  1345.             
  1346.             zipOut.flush();

  1348.         }catch(Exception e){
  1349.             throw new UtilsException(e.getMessage(),e);
  1350.         }

  1352.     }
  1353.     
  1354.     private org.openspcoop2.core.eventi.DatiEventoGenerico convertToDatiEventoGenericoSerializabled(DatiEventoGenerico eventoGenerico, String id){
  1355.         org.openspcoop2.core.eventi.DatiEventoGenerico e = new org.openspcoop2.core.eventi.DatiEventoGenerico();
  1356.         e.setIdEvento(id);
  1357.         e.setData(eventoGenerico.data);
  1358.         e.setDatiConsumatiThread(eventoGenerico.datiConsumatiThread);
  1359.         e.setDescrizione(eventoGenerico.descrizione);
  1360.         return e;
  1361.     }
  1362.     private org.openspcoop2.core.eventi.DatiEventoGenerico convertDBToDatiEventoGenericoSerializabled(DatabaseDatiEventoGenerico eventoGenerico, String id){
  1363.         org.openspcoop2.core.eventi.DatiEventoGenerico e = this.convertToDatiEventoGenericoSerializabled(eventoGenerico, id);
  1364.         if(eventoGenerico.codiceEvento!=null) {
  1365.             e.setCodiceEvento(eventoGenerico.codiceEvento.getValue());
  1366.         }
  1367.         return e;
  1368.     }
  1369.     
  1370.     
  1371.     @Deprecated
  1372.     /** Il meccanismo non funzionava, non si riusciva a riottenere uno stato corretto */
  1373.     public void initialize(InputStream in) throws UtilsException{
  1374.             
  1375.         if(in==null){
  1376.             return;
  1377.         }
  1378.         
  1379.         File f = null;
  1380.         String entryName = null;
  1381.         try {
  1382.             // Leggo InputStream
  1383.             byte [] bytesIn = Utilities.getAsByteArray(in);
  1384.             in.close();
  1385.             in = null;
  1386.             if(bytesIn==null || bytesIn.length<=0){
  1387.                 return;
  1388.             }
  1389.             f = FileSystemUtilities.createTempFile("controlloTraffico", ".tmp");
  1390.             FileSystemUtilities.writeFile(f, bytesIn);
  1391.         }catch(Exception e){
  1392.             try {
  1393.                 if(f!=null) {
  1394.                     java.nio.file.Files.delete(f.toPath());
  1395.                 }
  1396.             }catch(Exception eClose) {
  1397.                 // ignore
  1398.             }
  1399.             try{
  1400.                 if(in!=null)
  1401.                     in.close();
  1402.             }catch(Exception eClose){
  1403.                 // close
  1404.             }
  1405.             throw new UtilsException("["+entryName+"] "+e.getMessage(),e);
  1406.         }
  1407.         
  1408.         try (ZipFile zipFile = new ZipFile(f);){
  1409.             // Leggo Struttura ZIP

  1411.             String rootPackageDir = Costanti.OPENSPCOOP2_ARCHIVE_ROOT_DIR+File.separatorChar;
  1412.             
  1413.             String rootDir = null;
  1414.             
  1415.             org.openspcoop2.core.eventi.utils.serializer.JaxbDeserializer deserializer = new org.openspcoop2.core.eventi.utils.serializer.JaxbDeserializer();
  1416.             
  1417.             Iterator<ZipEntry> it = ZipUtilities.entries(zipFile, true);
  1418.             while (it.hasNext()) {
  1419.                 ZipEntry zipEntry = it.next();
  1420.                 entryName = ZipUtilities.operativeSystemConversion(zipEntry.getName());
  1421.                 
  1422.                 /**System.out.println("FILE NAME:  "+entryName);
  1423.                 System.out.println("SIZE:  "+zipEntry.getSize());*/

  1425.                 // Il codice dopo fissa il problema di inserire una directory nel package.
  1426.                 // Commentare la riga sotto per ripristinare il vecchio comportamento.
  1427.                 if(rootDir==null){
  1428.                     // Calcolo ROOT DIR
  1429.                     rootDir=ZipUtilities.getRootDir(entryName);
  1430.                 }
  1431.                 
  1432.                 if(!zipEntry.isDirectory()) {

  1434.                     FileDataSource fds = new FileDataSource(entryName);
  1435.                     String nome = fds.getName();
  1436.                     String tipo = nome.substring(nome.lastIndexOf(".")+1,nome.length()); 
  1437.                     tipo = tipo.toUpperCase();
  1438.                     /**System.out.println("VERIFICARE NAME["+nome+"] TIPO["+tipo+"]");*/
  1439.                     
  1440.                     try (InputStream inputStream = zipFile.getInputStream(zipEntry);){
  1441.                     
  1442.                         byte[]content = Utilities.getAsByteArray(inputStream);
  1443.                         
  1444.                         boolean inMemory = false;
  1445.                         String prefix = null;
  1446.                         if(entryName.startsWith((rootPackageDir+ZIP_IN_MEMORY)) ){
  1447.                             inMemory = true;
  1448.                             prefix = rootPackageDir+ZIP_IN_MEMORY+File.separatorChar;
  1449.                         }
  1450.                         else if(entryName.startsWith((rootPackageDir+ZIP_DB)) ){
  1451.                             inMemory = false;
  1452.                             prefix = rootPackageDir+ZIP_DB+File.separatorChar;
  1453.                         }
  1454.                         else {
  1455.                             throw new UtilsException("Entry ["+entryName+"] sconosciuta (Tipologia)");
  1456.                         }
  1457.                         
  1458.                         if(entryName.equals((prefix+ZIP_LAST_MAX_REQUESTS)) ){
  1459.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1460.                                     deserializer.readDatiEventoGenerico(content);
  1461.                             if(inMemory) {
  1462.                                 this.inMemoryLastMaxRequests = convertToDatiEventoGenerico(eventoGenericoSerialized);
  1463.                             }
  1464.                             else {
  1465.                                 this.dbLastMaxRequests = convertDBToDatiEventoGenerico(eventoGenericoSerialized);
  1466.                             }
  1467.                         }
  1468.                         
  1469.                         else if(entryName.equals((prefix+ZIP_LAST_MAX_REQUESTS_WARNING_ONLY)) ){
  1470.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1471.                                     deserializer.readDatiEventoGenerico(content);
  1472.                             if(inMemory) {
  1473.                                 this.inMemoryLastMaxRequestsWarningOnly = convertToDatiEventoGenerico(eventoGenericoSerialized);
  1474.                             }
  1475.                             else {
  1476.                                 this.dbLastMaxRequestsWarningOnly = convertDBToDatiEventoGenerico(eventoGenericoSerialized);
  1477.                             }
  1478.                         }
  1479.                         
  1480.                         else if(entryName.equals((prefix+ZIP_LAST_PDD_CONGESTIONATA)) ){
  1481.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1482.                                     deserializer.readDatiEventoGenerico(content);
  1483.                             if(inMemory) {
  1484.                                 this.inMemoryLastPddCongestionata = convertToDatiEventoGenerico(eventoGenericoSerialized);
  1485.                             }
  1486.                             else {
  1487.                                 this.dbLastPddCongestionata = convertDBToDatiEventoGenerico(eventoGenericoSerialized);
  1488.                             }
  1489.                         }
  1490.                         
  1491.                         else if(entryName.startsWith((prefix+ZIP_POLICY_GLOBALE)) ){
  1492.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1493.                                     deserializer.readDatiEventoGenerico(content);
  1494.                             if(inMemory) {
  1495.                                 this.inMemoryLastPolicyGlobaliViolated.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1496.                             }
  1497.                             else {
  1498.                                 this.dbLastPolicyGlobaliViolated.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1499.                             }
  1500.                         }
  1501.                         
  1502.                         else if(entryName.startsWith((prefix+ZIP_POLICY_GLOBALE_WARNING_ONLY)) ){
  1503.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1504.                                     deserializer.readDatiEventoGenerico(content);
  1505.                             if(inMemory) {
  1506.                                 this.inMemoryLastPolicyGlobaliViolatedWarningOnly.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1507.                             }
  1508.                             else {
  1509.                                 this.dbLastPolicyGlobaliViolatedWarningOnly.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1510.                             }
  1511.                         }
  1512.                         
  1513.                         else if(entryName.startsWith((prefix+ZIP_POLICY_API)) ){
  1514.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1515.                                     deserializer.readDatiEventoGenerico(content);
  1516.                             if(inMemory) {
  1517.                                 this.inMemoryLastPolicyAPIViolated.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1518.                             }
  1519.                             else {
  1520.                                 this.dbLastPolicyAPIViolated.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1521.                             }
  1522.                         }
  1523.                         
  1524.                         else if(entryName.startsWith((prefix+ZIP_POLICY_API_WARNING_ONLY)) ){
  1525.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1526.                                     deserializer.readDatiEventoGenerico(content);
  1527.                             if(inMemory) {
  1528.                                 this.inMemoryLastPolicyAPIViolatedWarningOnly.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1529.                             }
  1530.                             else {
  1531.                                 this.dbLastPolicyAPIViolatedWarningOnly.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1532.                             }
  1533.                         }
  1534.                         
  1535.                         else if(entryName.startsWith((prefix+ZIP_EVENTO_TIMEOUT_CONNESSIONE)) ){
  1536.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1537.                                     deserializer.readDatiEventoGenerico(content);
  1538.                             if(inMemory) {
  1539.                                 this.inMemoryLastTimeoutConnessione.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1540.                             }
  1541.                             else {
  1542.                                 this.dbLastTimeoutConnessione.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1543.                             }
  1544.                         }
  1545.                         
  1546.                         else if(entryName.startsWith((prefix+ZIP_EVENTO_TIMEOUT_RICHIESTA)) ){
  1547.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1548.                                     deserializer.readDatiEventoGenerico(content);
  1549.                             if(inMemory) {
  1550.                                 this.inMemoryLastTimeoutRichiesta.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1551.                             }
  1552.                             else {
  1553.                                 this.dbLastTimeoutRichiesta.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1554.                             }
  1555.                         }
  1556.                         
  1557.                         else if(entryName.startsWith((prefix+ZIP_EVENTO_TIMEOUT_RISPOSTA)) ){
  1558.                             org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized = 
  1559.                                     deserializer.readDatiEventoGenerico(content);
  1560.                             if(inMemory) {
  1561.                                 this.inMemoryLastTimeoutRisposta.put(eventoGenericoSerialized.getIdEvento(), convertToDatiEventoGenerico(eventoGenericoSerialized));
  1562.                             }
  1563.                             else {
  1564.                                 this.dbLastTimeoutRisposta.put(eventoGenericoSerialized.getIdEvento(), convertDBToDatiEventoGenerico(eventoGenericoSerialized));
  1565.                             }
  1566.                         }
  1567.                         
  1568.                         else{
  1569.                             throw new UtilsException("Entry ["+entryName+"] sconosciuta");
  1570.                         }
  1571.                         
  1572.                     }
  1573.                 }
  1574.                 
  1575.             }
  1576.             
  1577.         }catch(Exception e){
  1578.             throw new UtilsException("["+entryName+"] "+e.getMessage(),e);
  1579.         }
  1580.         finally{
  1581.             try {
  1582.                 if(f!=null) {
  1583.                     java.nio.file.Files.delete(f.toPath());
  1584.                 }
  1585.             }catch(Exception eClose) {
  1586.                 // ignore
  1587.             }
  1588.             try{
  1589.                 if(in!=null)
  1590.                     in.close();
  1591.             }catch(Exception eClose){
  1592.                 // close
  1593.             }
  1594.         }
  1595.         
  1596.     }
  1597.     
  1598.     private DatiEventoGenerico convertToDatiEventoGenerico(org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized){
  1599.         DatiEventoGenerico e = new DatiEventoGenerico();
  1600.         e.data = eventoGenericoSerialized.getData();
  1601.         e.datiConsumatiThread = eventoGenericoSerialized.isDatiConsumatiThread();
  1602.         e.descrizione = eventoGenericoSerialized.getDescrizione();
  1603.         return e;
  1604.     }
  1605.     private DatabaseDatiEventoGenerico convertDBToDatiEventoGenerico(org.openspcoop2.core.eventi.DatiEventoGenerico eventoGenericoSerialized){
  1606.         DatabaseDatiEventoGenerico e = new DatabaseDatiEventoGenerico();
  1607.         e.data = eventoGenericoSerialized.getData();
  1608.         e.datiConsumatiThread = eventoGenericoSerialized.isDatiConsumatiThread();
  1609.         e.descrizione = eventoGenericoSerialized.getDescrizione();
  1610.         if(eventoGenericoSerialized.getCodiceEvento()!=null) {
  1611.             e.codiceEvento = CodiceEventoControlloTraffico.toEnumConstant(eventoGenericoSerialized.getCodiceEvento());
  1612.         }
  1613.         return e;
  1614.     }
  1615. }


  1618. class DatiEventoGenerico{
  1619.     
  1620.     Date data;
  1621.     String descrizione;
  1622.     String configurazione;
  1623.     boolean datiConsumatiThread = true;
  1624.     
  1625.     public DatiEventoGenerico readAndConsume(){
  1626.         DatiEventoGenerico d = new DatiEventoGenerico();
  1627.         if(this.data!=null)
  1628.             d.data = new Date(this.data.getTime());
  1629.         if(this.descrizione!=null)
  1630.             d.descrizione = this.descrizione + "";
  1631.         if(this.configurazione!=null)
  1632.             d.configurazione = this.configurazione + "";
  1633.         d.datiConsumatiThread = this.datiConsumatiThread;
  1634.         
  1635.         this.datiConsumatiThread = true;
  1636.         
  1637.         return d;
  1638.     }
  1639. }

  1641. class DatabaseDatiEventoGenerico extends DatiEventoGenerico{
  1642.     
  1643.     CodiceEventoControlloTraffico codiceEvento;
  1644.     
  1645. }

Created with JaCoCo 0.8.8.202204050719