GestoreCacheControlloTraffico.java

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

  22. import java.text.SimpleDateFormat;
  23. import java.util.Collections;
  24. import java.util.Date;
  25. import java.util.List;
  26. import java.util.stream.Collectors;

  28. import org.openspcoop2.core.commons.CoreException;
  29. import org.openspcoop2.core.constants.TipoPdD;
  30. import org.openspcoop2.core.controllo_traffico.AttivazionePolicyFiltro;
  31. import org.openspcoop2.core.controllo_traffico.beans.DatiTransazione;
  32. import org.openspcoop2.core.controllo_traffico.beans.IDUnivocoGroupByPolicy;
  33. import org.openspcoop2.core.controllo_traffico.beans.RisultatoStatistico;
  34. import org.openspcoop2.core.controllo_traffico.beans.RisultatoStato;
  35. import org.openspcoop2.core.controllo_traffico.constants.TipoBanda;
  36. import org.openspcoop2.core.controllo_traffico.constants.TipoFinestra;
  37. import org.openspcoop2.core.controllo_traffico.constants.TipoLatenza;
  38. import org.openspcoop2.core.controllo_traffico.constants.TipoPeriodoStatistico;
  39. import org.openspcoop2.core.controllo_traffico.constants.TipoRisorsa;
  40. import org.openspcoop2.core.controllo_traffico.utils.PolicyUtilities;
  41. import org.openspcoop2.core.id.IDServizio;
  42. import org.openspcoop2.core.id.IDSoggetto;
  43. import org.openspcoop2.pdd.core.cache.CacheEntry;
  44. import org.openspcoop2.pdd.core.controllo_traffico.ConfigurazioneGatewayControlloTraffico;
  45. import org.openspcoop2.pdd.core.controllo_traffico.INotify;
  46. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  47. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  48. import org.openspcoop2.protocol.sdk.state.IState;
  49. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  50. import org.openspcoop2.utils.SemaphoreLock;
  51. import org.openspcoop2.utils.UtilsException;
  52. import org.openspcoop2.utils.cache.Cache;
  53. import org.openspcoop2.utils.cache.CacheAlgorithm;
  54. import org.openspcoop2.utils.cache.CacheType;
  55. import org.openspcoop2.utils.date.DateUtils;
  56. import org.slf4j.Logger;

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

  67.     /** Chiave della cache per l'autenticazione Buste  */
  68.     private static final String CONTROLLO_TRAFFICO_CACHE_NAME = "controlloTraffico";
  69.     /** Cache */
  70.     private static Cache cache = null;
  71. //  private static final Boolean semaphoreNumeroRichieste = true;
  72. //  private static final Boolean semaphoreOccupazioneBanda = true;
  73. //  private static final Boolean semaphoreLatenza = true;
  74. //  private static final Boolean semaphoreStato = true;
  75.     private static final org.openspcoop2.utils.Semaphore lockNumeroEsiti = new org.openspcoop2.utils.Semaphore("GestoreCacheControlloTraffico-NumeroEsiti");
  76.     private static final org.openspcoop2.utils.Semaphore lockNumeroRichieste = new org.openspcoop2.utils.Semaphore("GestoreCacheControlloTraffico-NumeroRichieste");
  77.     private static final org.openspcoop2.utils.Semaphore lockOccupazioneBanda = new org.openspcoop2.utils.Semaphore("GestoreCacheControlloTraffico-OccupazioneBanda");
  78.     private static final org.openspcoop2.utils.Semaphore lockLatenza = new org.openspcoop2.utils.Semaphore("GestoreCacheControlloTraffico-Latenza");
  79.     private static final org.openspcoop2.utils.Semaphore lockStato = new org.openspcoop2.utils.Semaphore("GestoreCacheControlloTraffico-Stato");

  81.     /* --------------- Cache --------------------*/
  82.     public static boolean isCacheAbilitata() throws Exception{
  83.         return cache!=null;
  84.     }
  85.     public static void resetCache() throws Exception{
  86.         try{
  87.             if(cache!=null){
  88.                 cache.clear();
  89.             }
  90.         }catch(Exception e){
  91.             throw new Exception("Reset della cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  92.         }
  93.     }
  94.     public static String printStatsCache(String separator) throws Exception{
  95.         try{
  96.             if(cache!=null){
  97.                 try{
  98.                     return cache.printStats(separator);
  99.                 }catch(Exception e){
  100.                     throw new Exception(e.getMessage(),e);
  101.                 }
  102.             }else{
  103.                 throw new Exception("Cache non abilitata");
  104.             }
  105.         }catch(Exception e){
  106.             throw new Exception("Visualizzazione Statistiche riguardante la cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  107.         }
  108.     }
  109.     public static void abilitaCache() throws Exception{
  110.         try{
  111.             if(cache!=null)
  112.                 throw new Exception("Cache gia' abilitata");
  113.             else{
  114.                 _abilitaCache();
  115.             }
  116.         }catch(Exception e){
  117.             throw new Exception("Abilitazione cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  118.         }
  119.     }
  120.     private static synchronized void _abilitaCache() throws Exception{
  121.         try{
  122.             if(cache==null) {
  123.                 cache = new Cache(CacheType.JCS, CONTROLLO_TRAFFICO_CACHE_NAME); // lascio JCS come default abilitato via jmx
  124.                 cache.build();
  125.             }
  126.         }catch(Exception e){
  127.             throw new Exception("Abilitazione cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  128.         }
  129.     }
  130.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, Logger log) throws Exception{
  131.         try{
  132.             if(cache!=null)
  133.                 throw new Exception("Cache gia' abilitata");
  134.             else{
  135.                 int dimensione = -1;
  136.                 if(dimensioneCache!=null){
  137.                     dimensione = dimensioneCache.intValue();
  138.                 }
  139.                 initCache(CacheType.JCS, dimensione, algoritmoCacheLRU, itemIdleTime, itemLifeSecond, log); // lascio JCS come default abilitato via jmx
  140.             }
  141.         }catch(Exception e){
  142.             throw new Exception("Abilitazione cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  143.         }
  144.     }
  145.     public static void disabilitaCache() throws Exception{
  146.         try{
  147.             if(cache==null)
  148.                 throw new Exception("Cache gia' disabilitata");
  149.             else{
  150.                 _disabilitaCache();
  151.             }
  152.         }catch(Exception e){
  153.             throw new Exception("Disabilitazione cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  154.         }
  155.     }
  156.     private static synchronized void _disabilitaCache() throws Exception{
  157.         try{
  158.             if(cache!=null){
  159.                 cache.clear();
  160.                 cache = null;
  161.             }
  162.         }catch(Exception e){
  163.             throw new Exception("Disabilitazione cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  164.         }
  165.     }
  166.     public static String listKeysCache(String separator) throws Exception{
  167.         try{
  168.             if(cache!=null){
  169.                 try{
  170.                     return cache.printKeys(separator);
  171.                 }catch(Exception e){
  172.                     throw new Exception(e.getMessage(),e);
  173.                 }
  174.             }else{
  175.                 throw new Exception("Cache non abilitata");
  176.             }
  177.         }catch(Exception e){
  178.             throw new Exception("Visualizzazione chiavi presenti nella cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  179.         }
  180.     }
  181.     
  182.     public static String getObjectCache(String key) throws Exception{
  183.         try{
  184.             if(cache!=null){
  185.                 try{
  186.                     Object o = cache.get(key);
  187.                     if(o!=null){
  188.                         return o.toString();
  189.                     }else{
  190.                         return "oggetto con chiave ["+key+"] non presente";
  191.                     }
  192.                 }catch(Exception e){
  193.                     throw new Exception(e.getMessage(),e);
  194.                 }
  195.             }else{
  196.                 throw new Exception("Cache non abilitata");
  197.             }
  198.         }catch(Exception e){
  199.             throw new Exception("Visualizzazione oggetto presente nella cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  200.         }
  201.     }
  202.     
  203.     public static void removeObjectCache(String key) throws Exception{
  204.         try{
  205.             if(cache!=null){
  206.                 try{
  207.                     cache.remove(key);
  208.                 }catch(Exception e){
  209.                     throw new Exception(e.getMessage(),e);
  210.                 }
  211.             }else{
  212.                 throw new Exception("Cache non abilitata");
  213.             }
  214.         }catch(Exception e){
  215.             throw new Exception("Rimozione oggetto presente nella cache per i dati sul controllo del traffico non riuscita: "+e.getMessage(),e);
  216.         }
  217.     }
  218.     
  219.     

  221.     public static void initializeCache(CacheType cacheType, Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, Logger log) throws Exception{
  222.         int dimensione = -1;
  223.         if(dimensioneCache!=null){
  224.             dimensione = dimensioneCache.intValue();
  225.         }
  226.         initCache(cacheType, dimensione, algoritmoCacheLRU, itemIdleTime, itemLifeSecond, log);
  227.     }
  228.     
  229.     private static void initCache(CacheType cacheType, Integer dimensioneCache,boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws Exception{
  230.         
  231.         cache = new Cache(cacheType, CONTROLLO_TRAFFICO_CACHE_NAME);
  232.     
  233.         // dimensione
  234.         if(dimensioneCache!=null && dimensioneCache>0){
  235.             try{
  236.                 String msg = "Dimensione della cache (ControlloTraffico) impostata al valore: "+dimensioneCache;
  237.                 alog.info(msg);
  238.                 cache.setCacheSize(dimensioneCache);
  239.             }catch(Exception error){
  240.                 String msg = "Parametro errato per la dimensione della cache (ControlloTraffico): "+error.getMessage();
  241.                 alog.error(msg);
  242.                 throw new Exception(msg,error);
  243.             }
  244.         }
  245.         
  246.         // algoritno
  247.         String msg = "Algoritmo di cache (ControlloTraffico) impostato al valore: LRU";
  248.         if(!algoritmoCacheLRU){
  249.             msg = "Algoritmo di cache (ControlloTraffico) impostato al valore: MRU";
  250.         }
  251.         alog.info(msg);
  252.         if(!algoritmoCacheLRU)
  253.             cache.setCacheAlgoritm(CacheAlgorithm.MRU);
  254.         else
  255.             cache.setCacheAlgoritm(CacheAlgorithm.LRU);
  256.         
  257.         
  258.         // idle time
  259.         if(itemIdleTime!=null && itemIdleTime>0){
  260.             try{
  261.                 msg = "Attributo 'IdleTime' (ControlloTraffico) impostato al valore: "+itemIdleTime;
  262.                 alog.info(msg);
  263.                 cache.setItemIdleTime(itemIdleTime);
  264.             }catch(Exception error){
  265.                 msg = "Parametro errato per l'attributo 'IdleTime' (ControlloTraffico): "+error.getMessage();
  266.                 alog.error(msg);
  267.                 throw new Exception(msg,error);
  268.             }
  269.         }
  270.         
  271.         // LifeSecond
  272.         long longItemLife = -1; 
  273.         if(itemLifeSecond!=null && itemLifeSecond>0){
  274.             longItemLife = itemLifeSecond.longValue();
  275.         }
  276.         try{
  277.             msg = "Attributo 'MaxLifeSecond' (ControlloTraffico) impostato al valore: "+longItemLife;
  278.             alog.info(msg);
  279.             cache.setItemLifeTime(longItemLife);
  280.         }catch(Exception error){
  281.             msg = "Parametro errato per l'attributo 'MaxLifeSecond' (ControlloTraffico): "+error.getMessage();
  282.             alog.error(msg);
  283.             throw new Exception(msg,error);
  284.         }
  285.         
  286.         cache.build();
  287.         
  288.     }
  289.     
  290.     @SuppressWarnings("deprecation")
  291.     @Deprecated
  292.     public static void disableSyncronizedGet() throws UtilsException {
  293.         if(cache==null) {
  294.             throw new UtilsException("Cache disabled");
  295.         }
  296.         cache.disableSyncronizedGet();
  297.     }
  298.     @SuppressWarnings("deprecation")
  299.     @Deprecated
  300.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  301.         if(cache==null) {
  302.             throw new UtilsException("Cache disabled");
  303.         }
  304.         return cache.isDisableSyncronizedGet();
  305.     }
  306.     
  307.     
  308.     
  309.     private static GestoreCacheControlloTraffico staticInstance = null;
  310.     public static synchronized void initialize(ConfigurazioneGatewayControlloTraffico configurazioneControlloTraffico) throws CoreException{
  311.         if(staticInstance==null){
  312.             staticInstance = new GestoreCacheControlloTraffico(configurazioneControlloTraffico);
  313.         }
  314.     }
  315.     public static GestoreCacheControlloTraffico getInstance() throws CoreException{
  316.         if(staticInstance==null){
  317.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  318.             synchronized (GestoreCacheControlloTraffico.class) {
  319.                 throw new CoreException("GestoreCacheControlloTraffico non inizializzato");
  320.             }
  321.         }
  322.         return staticInstance;
  323.     }
  324.     
  325.     private DatiStatisticiDAOManager datiStatisticiReader = null;
  326.     private INotify datiNotifierReader = null;
  327.     private Logger log;
  328.     private boolean debug;
  329.     private ConfigurazioneGatewayControlloTraffico configurazioneControlloTraffico;
  330.     
  331.     private GestoreCacheControlloTraffico(ConfigurazioneGatewayControlloTraffico configurazioneControlloTraffico) throws CoreException {
  332.         this.datiStatisticiReader = DatiStatisticiDAOManager.getInstance();
  333.         if(configurazioneControlloTraffico.isNotifierEnabled()){
  334.             this.datiNotifierReader = configurazioneControlloTraffico.getNotifier();
  335.         }
  336.         this.configurazioneControlloTraffico = configurazioneControlloTraffico;
  337.         this.debug = this.configurazioneControlloTraffico.isDebug();
  338.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopControlloTraffico(this.debug);
  339.     }
  340.     
  341.     
  342.     
  343.     
  344.     /*********************** NUMERO ESITI ******************************* */
  345.     public RisultatoStatistico readNumeroEsiti(TipoPeriodoStatistico tipoPeriodo, Integer periodLength, Date endDate, 
  346.             List<Integer> esiti, IDServizio servizio, IDSoggetto mittente, List<String> ignoreOperations, DatiTransazione datiTransazione, IState state, Integer lifetimeSecond) throws Exception{
  347.                         
  348.         // BuildKey
  349.         SimpleDateFormat dateformat; 
  350.         switch(tipoPeriodo) {
  351.         case ORARIO: dateformat = DateUtils.getSimpleDateFormatHour(); break;
  352.         case GIORNALIERO: dateformat = DateUtils.getSimpleDateFormatDay(); break;
  353.         case SETTIMANALE: dateformat = DateUtils.getSimpleDateFormatDay(); break;
  354.         case MENSILE: dateformat = DateUtils.getSimpleDateFormatDay(); break;
  355.         default: dateformat = DateUtils.getSimpleDateFormatDay(); break;
  356.         }
  357.         
  358.         
  359.         StringBuilder bfKey = new StringBuilder(servizio.toString());       
  360.         if (ignoreOperations != null) {
  361.             Collections.sort(ignoreOperations);
  362.             bfKey.append("~" + ignoreOperations);
  363.         }
  364.         bfKey.append(mittente == null ? "" : " " + mittente);
  365.         bfKey.append(esiti == null ? "" : " " + String.join(",", esiti.stream().map(Object::toString).collect(Collectors.toList())));
  366.         bfKey.append(" [").append(dateformat.format(endDate));
  367.         bfKey.append("-").append(periodLength).append(" ").append(tipoPeriodo).append("]");
  368.         String key = bfKey.toString();
  369.         
  370.         // Search key
  371.         RisultatoStatistico risultato = null;
  372.         if(GestoreCacheControlloTraffico.cache!=null){
  373.             risultato = this.readNumeroEsiti(key, tipoPeriodo, periodLength, endDate, 
  374.                 esiti, servizio, mittente, ignoreOperations, datiTransazione, state, lifetimeSecond);
  375.         }
  376.         else{
  377.             risultato = this.datiStatisticiReader.readNumeroEsiti(key, tipoPeriodo, periodLength, endDate, 
  378.                     esiti, servizio, mittente, ignoreOperations, datiTransazione, state);
  379.         }
  380.         return risultato;
  381.     }
  382.     
  383.     private RisultatoStatistico readNumeroEsiti(String keyCache, TipoPeriodoStatistico tipoPeriodo, Integer periodLength, Date endDate, 
  384.             List<Integer> esiti, IDServizio servizio, IDSoggetto mittente, List<String> ignoreOperations, DatiTransazione datiTransazione, IState state, Integer lifetimeSecond) throws Exception{

  386.         RisultatoStatistico obj = null;
  387.         try{

  389.             if(keyCache == null)
  390.                 throw new Exception("KeyCache non definita");

  392.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  393.             if(cache!=null){
  394.                 org.openspcoop2.utils.cache.CacheResponse response = 
  395.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  396.                 if(response != null){
  397.                     if(response.getObject()!=null){
  398.                         this.log.debug("Oggetto (tipo:{}) con chiave [{}] valore[{}] in cache.", response.getObject().getClass().getName(), keyCache, response.getObject());
  399.                         @SuppressWarnings("unchecked")
  400.                         CacheEntry<RisultatoStatistico> entry = (CacheEntry<RisultatoStatistico>) response.getObject();
  401.                         if (entry.isValid())
  402.                             return entry.getObject();
  403.                     }else if(response.getException()!=null){
  404.                         this.log.debug("Eccezione (tipo:{}) con chiave [{}]", response.getException().getClass().getName().concat(keyCache), keyCache);
  405.                         throw (Exception) response.getException();
  406.                     }else{
  407.                         this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  408.                     }
  409.                 }
  410.             }
  411.             
  412.             String idTransazione = datiTransazione!=null ? datiTransazione.getIdTransazione() : null;
  413.             SemaphoreLock lock = lockNumeroEsiti.acquire("readNumeroEsitiInCache", idTransazione);
  414.             try {
  415.                 
  416.                 // se e' attiva una cache provo ad utilizzarla
  417.                 if(cache!=null){
  418.                     org.openspcoop2.utils.cache.CacheResponse response = 
  419.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  420.                     if(response != null){
  421.                         if(response.getObject()!=null){
  422.                             this.log.debug("Oggetto (tipo:{}) con chiave [{}] valore[{}] in cache.", response.getObject().getClass().getName(), keyCache, response.getObject());
  423.                             @SuppressWarnings("unchecked")
  424.                             CacheEntry<RisultatoStatistico> entry = (CacheEntry<RisultatoStatistico>) response.getObject();
  425.                             if (entry.isValid())
  426.                                 return entry.getObject();
  427.                         }else if(response.getException()!=null){
  428.                             this.log.debug("Eccezione (tipo:{}) con chiave [{}] in cache.", response.getException().getClass().getName(), keyCache);
  429.                             throw (Exception) response.getException();
  430.                         }else{
  431.                             this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  432.                         }
  433.                     }
  434.                 }
  435.     
  436.                 // Effettuo le query nella mia gerarchia di registri.
  437.                 this.log.debug("oggetto con chiave [{}] non in cache, effettuo ricerca...", keyCache);
  438.                 try{
  439.                     obj = this.datiStatisticiReader.readNumeroEsiti(keyCache, tipoPeriodo, periodLength, endDate, 
  440.                          esiti, servizio, mittente,  ignoreOperations, datiTransazione, state);
  441.                 }catch(Exception e){
  442.                     throw e;
  443.                 }
  444.     
  445.                 // Aggiungo la risposta in cache (se esiste una cache)  
  446.                 // Se ho una eccezione aggiungo in cache solo una not found
  447.                 if( cache!=null ){  
  448.                     if(obj!=null){
  449.                         this.log.debug("Aggiungo oggetto con chiave [{}] valore[{}] in cache", keyCache, obj);
  450.                     }else{
  451.                         throw new Exception("Ricerca ha ritornato un valore null");
  452.                     }
  453.                     try{    
  454.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  455.                         responseCache.setObject(new CacheEntry<RisultatoStatistico>(obj, lifetimeSecond * 1000l));
  456.                         
  457.                         cache.put(keyCache,responseCache);
  458.                     }catch(UtilsException e){
  459.                         this.log.error("Errore durante l'inserimento in cache con chiave [{}] valore[{}]: {}", keyCache, obj, e.getMessage());
  460.                     }
  461.                 }
  462.             }finally {
  463.                 lockNumeroEsiti.release(lock, "readNumeroEsitiInCache", idTransazione);
  464.             }

  466.         }
  467.         catch(Exception e){
  468.             this.log.error(e.getMessage(),e);
  469.             throw new Exception("NumeroEsiti, Algoritmo di Cache fallito: "+e.getMessage(),e);
  470.         }

  472.         return obj;
  473.     }
  474.     
  475.     
  476.     /* ********************** NUMERO RICHIESTE ************************** */
  477.     
  478.     public RisultatoStatistico readNumeroRichieste(TipoRisorsa tipoRisorsa, 
  479.             Date leftInterval, Date rightInterval,
  480.             TipoFinestra tipoFinestra, TipoPeriodoStatistico tipoPeriodo,
  481.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  482.             IState state,
  483.             RequestInfo requestInfo,
  484.             IProtocolFactory<?> protocolFactory) throws Exception{
  485.                         
  486.         // BuildKey
  487.         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  488.         
  489.         TipoPdD tipoPdDTransazioneInCorso = datiTransazione.getTipoPdD();
  490.         
  491.         StringBuilder bfKey = new StringBuilder(tipoRisorsa.getValue()+" ");
  492.         bfKey.append(tipoFinestra.getValue());
  493.         bfKey.append(" ").append(tipoPeriodo.getValue());
  494.         bfKey.append(" ").append(tipoPdDTransazioneInCorso.getTipo());
  495.         bfKey.append(" [").append(dateformat.format(leftInterval)).append("]");
  496.         bfKey.append("-[").append(dateformat.format(rightInterval)).append("]");
  497.         bfKey.append(" GroupBy ");
  498.         bfKey.append(groupByPolicy.toString());
  499.         if(filtro!=null && filtro.isEnabled()) {
  500.             bfKey.append(" Filtro ");
  501.             bfKey.append(PolicyUtilities.toStringFilter(filtro));
  502.         }
  503.         String key = bfKey.toString();
  504.         
  505.         //System.out.println("CERCO OGGETTO CON CHIAVE ["+key+"]");
  506.         
  507.         RisultatoStatistico risultato = null;
  508.         if(GestoreCacheControlloTraffico.cache!=null){
  509.             risultato = this.readNumeroRichiesteInCache(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  510.                     datiTransazione, groupByPolicy, filtro,
  511.                     state,
  512.                     requestInfo,
  513.                     protocolFactory);
  514.         }
  515.         else{
  516.             risultato = this.datiStatisticiReader.readNumeroRichieste(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  517.                     datiTransazione, groupByPolicy, filtro,
  518.                     state,
  519.                     requestInfo,
  520.                     protocolFactory );
  521.         }
  522.         return risultato;
  523.     }
  524.     
  525.     private RisultatoStatistico readNumeroRichiesteInCache(String keyCache,
  526.             TipoRisorsa tipoRisorsa,TipoFinestra tipoFinestra,TipoPeriodoStatistico tipoPeriodo, 
  527.             Date leftInterval, Date rightInterval,
  528.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  529.             IState state,
  530.             RequestInfo requestInfo,
  531.             IProtocolFactory<?> protocolFactory) throws Exception{

  533.         RisultatoStatistico obj = null;
  534.         try{

  536.             if(keyCache == null)
  537.                 throw new Exception("KeyCache non definita");

  539.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  540.             if(cache!=null){
  541.                 org.openspcoop2.utils.cache.CacheResponse response = 
  542.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  543.                 if(response != null){
  544.                     if(response.getObject()!=null){
  545.                         this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  546.                         //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  547.                         return (RisultatoStatistico) response.getObject();
  548.                     }else if(response.getException()!=null){
  549.                         this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  550.                         throw (Exception) response.getException();
  551.                     }else{
  552.                         this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  553.                     }
  554.                 }
  555.             }
  556.             
  557.             String idTransazione = datiTransazione!=null ? datiTransazione.getIdTransazione() : null;
  558.             //synchronized (semaphoreNumeroRichieste) {
  559.             SemaphoreLock lock = lockNumeroRichieste.acquire("readNumeroRichiesteInCache", idTransazione);
  560.             try {
  561.                 
  562.                 // se e' attiva una cache provo ad utilizzarla
  563.                 if(cache!=null){
  564.                     org.openspcoop2.utils.cache.CacheResponse response = 
  565.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  566.                     if(response != null){
  567.                         if(response.getObject()!=null){
  568.                             this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  569.                             //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  570.                             return (RisultatoStatistico) response.getObject();
  571.                         }else if(response.getException()!=null){
  572.                             this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  573.                             throw (Exception) response.getException();
  574.                         }else{
  575.                             this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  576.                         }
  577.                     }
  578.                 }
  579.     
  580.                 // Effettuo le query nella mia gerarchia di registri.
  581.                 this.log.debug("oggetto con chiave ["+keyCache+"] non in cache, effettuo ricerca...");
  582.                 try{
  583.                     obj = this.datiStatisticiReader.readNumeroRichieste(keyCache, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  584.                             datiTransazione, groupByPolicy, filtro,
  585.                             state,
  586.                             requestInfo,
  587.                             protocolFactory);
  588.                 }catch(Exception e){
  589.                     throw e;
  590.                 }
  591.     
  592.                 // Aggiungo la risposta in cache (se esiste una cache)  
  593.                 // Se ho una eccezione aggiungo in cache solo una not found
  594.                 if( cache!=null ){  
  595.                     if(obj!=null){
  596.                         this.log.debug("Aggiungo oggetto con chiave ["+keyCache+"] valore["+obj+"] in cache");
  597.                     }else{
  598.                         throw new Exception("Ricerca ha ritornato un valore null");
  599.                     }
  600.                     try{    
  601.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  602.                         responseCache.setObject((java.io.Serializable)obj);
  603.                         cache.put(keyCache,responseCache);
  604.                     }catch(UtilsException e){
  605.                         this.log.error("Errore durante l'inserimento in cache con chiave ["+keyCache+"] valore["+obj+"]: "+e.getMessage());
  606.                     }
  607.                 }
  608.             }finally {
  609.                 lockNumeroRichieste.release(lock, "readNumeroRichiesteInCache", idTransazione);
  610.             }

  612.         }
  613.         catch(Exception e){
  614.             this.log.error(e.getMessage(),e);
  615.             throw new Exception("NumeroRichieste, Algoritmo di Cache fallito: "+e.getMessage(),e);
  616.         }

  618.         return obj;
  619.     }
  620.     
  621.     
  622.     
  623.     
  624.     
  625.     
  626.     /* ********************** OCCUPAZIONE BANDA ************************** */
  627.     
  628.     public RisultatoStatistico readOccupazioneBanda(TipoRisorsa tipoRisorsa, 
  629.             Date leftInterval, Date rightInterval,
  630.             TipoFinestra tipoFinestra, TipoPeriodoStatistico tipoPeriodo,
  631.             TipoBanda tipoBanda,
  632.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  633.             IState state,
  634.             RequestInfo requestInfo,
  635.             IProtocolFactory<?> protocolFactory) throws Exception{
  636.         
  637.         // BuildKey
  638.         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  639.         
  640.         TipoPdD tipoPdDTransazioneInCorso = datiTransazione.getTipoPdD();
  641.         
  642.         StringBuilder bfKey = new StringBuilder(tipoRisorsa.getValue()+" ");
  643.         bfKey.append(tipoFinestra.getValue());
  644.         bfKey.append(" ").append(tipoPeriodo.getValue());
  645.         bfKey.append(" ").append(tipoBanda.getValue());
  646.         bfKey.append(" ").append(tipoPdDTransazioneInCorso.getTipo());
  647.         bfKey.append(" [").append(dateformat.format(leftInterval)).append("]");
  648.         bfKey.append("-[").append(dateformat.format(rightInterval)).append("]");
  649.         bfKey.append(" GroupBy ");
  650.         bfKey.append(groupByPolicy.toString());
  651.         if(filtro!=null && filtro.isEnabled()) {
  652.             bfKey.append(" Filtro ");
  653.             bfKey.append(PolicyUtilities.toStringFilter(filtro));
  654.         }
  655.         String key = bfKey.toString();
  656.         
  657.         //System.out.println("CERCO OGGETTO CON CHIAVE ["+key+"]");
  658.         
  659.         RisultatoStatistico risultato = null;
  660.         if(GestoreCacheControlloTraffico.cache!=null){
  661.             risultato = this.readOccupazioneBandaInCache(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, tipoBanda,
  662.                     datiTransazione, groupByPolicy, filtro,
  663.                     state,
  664.                     requestInfo,
  665.                     protocolFactory);
  666.         }
  667.         else{
  668.             risultato = this.datiStatisticiReader.readOccupazioneBanda(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, tipoBanda,
  669.                     datiTransazione, groupByPolicy, filtro,
  670.                     state,
  671.                     requestInfo,
  672.                     protocolFactory);
  673.         }
  674.         return risultato;
  675.     }
  676.     
  677.     private RisultatoStatistico readOccupazioneBandaInCache(String keyCache,
  678.             TipoRisorsa tipoRisorsa, TipoFinestra tipoFinestra,TipoPeriodoStatistico tipoPeriodo, 
  679.             Date leftInterval, Date rightInterval,
  680.             TipoBanda tipoBanda,
  681.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  682.             IState state,
  683.             RequestInfo requestInfo,
  684.             IProtocolFactory<?> protocolFactory) throws Exception{

  686.         RisultatoStatistico obj = null;
  687.         try{

  689.             if(keyCache == null)
  690.                 throw new Exception("KeyCache non definita");

  692.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  693.             if(cache!=null){
  694.                 org.openspcoop2.utils.cache.CacheResponse response = 
  695.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  696.                 if(response != null){
  697.                     if(response.getObject()!=null){
  698.                         this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  699.                         //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  700.                         return (RisultatoStatistico) response.getObject();
  701.                     }else if(response.getException()!=null){
  702.                         this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  703.                         throw (Exception) response.getException();
  704.                     }else{
  705.                         this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  706.                     }
  707.                 }
  708.             }
  709.             
  710.             String idTransazione = datiTransazione!=null ? datiTransazione.getIdTransazione() : null;
  711.             //synchronized (semaphoreOccupazioneBanda) {
  712.             SemaphoreLock lock = lockOccupazioneBanda.acquire("readOccupazioneBandaInCache", idTransazione);
  713.             try {
  714.                 
  715.                 // se e' attiva una cache provo ad utilizzarla
  716.                 if(cache!=null){
  717.                     org.openspcoop2.utils.cache.CacheResponse response = 
  718.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  719.                     if(response != null){
  720.                         if(response.getObject()!=null){
  721.                             this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  722.                             //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  723.                             return (RisultatoStatistico) response.getObject();
  724.                         }else if(response.getException()!=null){
  725.                             this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  726.                             throw (Exception) response.getException();
  727.                         }else{
  728.                             this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  729.                         }
  730.                     }
  731.                 }
  732.     
  733.                 // Effettuo le query nella mia gerarchia di registri.
  734.                 this.log.debug("oggetto con chiave ["+keyCache+"] non in cache, effettuo ricerca...");
  735.                 try{
  736.                     obj = this.datiStatisticiReader.readOccupazioneBanda(keyCache, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, tipoBanda,
  737.                             datiTransazione, groupByPolicy, filtro,
  738.                             state,
  739.                             requestInfo,
  740.                             protocolFactory);
  741.                 }catch(Exception e){
  742.                     throw e;
  743.                 }
  744.     
  745.                 // Aggiungo la risposta in cache (se esiste una cache)  
  746.                 // Se ho una eccezione aggiungo in cache solo una not found
  747.                 if( cache!=null ){  
  748.                     if(obj!=null){
  749.                         this.log.debug("Aggiungo oggetto con chiave ["+keyCache+"] valore["+obj+"] in cache");
  750.                     }else{
  751.                         throw new Exception("Ricerca ha ritornato un valore null");
  752.                     }
  753.                     try{    
  754.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  755.                         responseCache.setObject((java.io.Serializable)obj);
  756.                         cache.put(keyCache,responseCache);
  757.                     }catch(UtilsException e){
  758.                         this.log.error("Errore durante l'inserimento in cache con chiave ["+keyCache+"] valore["+obj+"]: "+e.getMessage());
  759.                     }
  760.                 }
  761.                 
  762.             }finally {
  763.                 lockOccupazioneBanda.release(lock, "readOccupazioneBandaInCache", idTransazione);
  764.             }

  766.         }
  767.         catch(Exception e){
  768.             this.log.error(e.getMessage(),e);
  769.             throw new Exception("OccupazioneBanda, Algoritmo di Cache fallito: "+e.getMessage(),e);
  770.         }

  772.         return obj;
  773.     }
  774.     
  775.     
  776.     
  777.     
  778.     
  779.     
  780.     /* ********************** LATENZA ************************** */
  781.     
  782.     public RisultatoStatistico readLatenza(TipoRisorsa tipoRisorsa,
  783.             Date leftInterval, Date rightInterval,
  784.             TipoFinestra tipoFinestra, TipoPeriodoStatistico tipoPeriodo,
  785.             TipoLatenza tipoLatenza,
  786.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  787.             IState state,
  788.             RequestInfo requestInfo,
  789.             IProtocolFactory<?> protocolFactory) throws Exception{
  790.         
  791.         // BuildKey
  792.         SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  793.         
  794.         TipoPdD tipoPdDTransazioneInCorso = datiTransazione.getTipoPdD();
  795.         
  796.         StringBuilder bfKey = null;
  797.         bfKey = new StringBuilder(tipoRisorsa.getValue()+" ");
  798.         bfKey.append(tipoFinestra.getValue());
  799.         bfKey.append(" ").append(tipoPeriodo.getValue());
  800.         bfKey.append(" ").append(tipoLatenza.getValue());
  801.         bfKey.append(" ").append(tipoPdDTransazioneInCorso.getTipo());
  802.         bfKey.append(" [").append(dateformat.format(leftInterval)).append("]");
  803.         bfKey.append("-[").append(dateformat.format(rightInterval)).append("]");
  804.         bfKey.append(" GroupBy ");
  805.         bfKey.append(groupByPolicy.toString());
  806.         if(filtro!=null && filtro.isEnabled()) {
  807.             bfKey.append(" Filtro ");
  808.             bfKey.append(PolicyUtilities.toStringFilter(filtro));
  809.         }
  810.         String key = bfKey.toString();
  811.         
  812.         //System.out.println("CERCO OGGETTO CON CHIAVE ["+key+"]");
  813.         
  814.         RisultatoStatistico risultato = null;
  815.         if(GestoreCacheControlloTraffico.cache!=null){
  816.             risultato = this.readLatenzaInCache(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  817.                     tipoLatenza, datiTransazione, groupByPolicy, filtro,
  818.                     state,
  819.                     requestInfo,
  820.                     protocolFactory);
  821.         }
  822.         else{
  823.             risultato = this.datiStatisticiReader.readLatenza(key, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  824.                     tipoLatenza, datiTransazione, groupByPolicy, filtro,
  825.                     state,
  826.                     requestInfo,
  827.                     protocolFactory);
  828.         }
  829.         return risultato;
  830.     }
  831.     
  832.     private RisultatoStatistico readLatenzaInCache(String keyCache,
  833.             TipoRisorsa tipoRisorsa,TipoFinestra tipoFinestra,TipoPeriodoStatistico tipoPeriodo, 
  834.             Date leftInterval, Date rightInterval,
  835.             TipoLatenza tipoLatenza,
  836.             DatiTransazione datiTransazione,IDUnivocoGroupByPolicy groupByPolicy, AttivazionePolicyFiltro filtro,
  837.             IState state,
  838.             RequestInfo requestInfo,
  839.             IProtocolFactory<?> protocolFactory) throws Exception{

  841.         RisultatoStatistico obj = null;
  842.         try{

  844.             if(keyCache == null)
  845.                 throw new Exception("KeyCache non definita");

  847.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  848.             if(cache!=null){
  849.                 org.openspcoop2.utils.cache.CacheResponse response = 
  850.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  851.                 if(response != null){
  852.                     if(response.getObject()!=null){
  853.                         this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  854.                         //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  855.                         return (RisultatoStatistico) response.getObject();
  856.                     }else if(response.getException()!=null){
  857.                         this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  858.                         throw (Exception) response.getException();
  859.                     }else{
  860.                         this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  861.                     }
  862.                 }
  863.             }
  864.             
  865.             String idTransazione = datiTransazione!=null ? datiTransazione.getIdTransazione() : null;
  866.             //synchronized (semaphoreLatenza) {
  867.             SemaphoreLock lock = lockLatenza.acquire("readLatenzaInCache", idTransazione);
  868.             try {
  869.                 
  870.                 // se e' attiva una cache provo ad utilizzarla
  871.                 if(cache!=null){
  872.                     org.openspcoop2.utils.cache.CacheResponse response = 
  873.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  874.                     if(response != null){
  875.                         if(response.getObject()!=null){
  876.                             this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  877.                             //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  878.                             return (RisultatoStatistico) response.getObject();
  879.                         }else if(response.getException()!=null){
  880.                             this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  881.                             throw (Exception) response.getException();
  882.                         }else{
  883.                             this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  884.                         }
  885.                     }
  886.                 }
  887.     
  888.                 // Effettuo le query nella mia gerarchia di registri.
  889.                 this.log.debug("oggetto con chiave ["+keyCache+"] non in cache, effettuo ricerca...");
  890.                 try{
  891.                     obj = this.datiStatisticiReader.readLatenza(keyCache, tipoRisorsa, tipoFinestra, tipoPeriodo, leftInterval, rightInterval, 
  892.                             tipoLatenza, datiTransazione, groupByPolicy, filtro,
  893.                             state,
  894.                             requestInfo,
  895.                             protocolFactory);
  896.                 }catch(Exception e){
  897.                     throw e;
  898.                 }
  899.     
  900.                 // Aggiungo la risposta in cache (se esiste una cache)  
  901.                 // Se ho una eccezione aggiungo in cache solo una not found
  902.                 if( cache!=null ){  
  903.                     if(obj!=null){
  904.                         this.log.debug("Aggiungo oggetto con chiave ["+keyCache+"] valore["+obj+"] in cache");
  905.                     }else{
  906.                         throw new Exception("Ricerca ha ritornato un valore null");
  907.                     }
  908.                     try{    
  909.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  910.                         responseCache.setObject((java.io.Serializable)obj);
  911.                         cache.put(keyCache,responseCache);
  912.                     }catch(UtilsException e){
  913.                         this.log.error("Errore durante l'inserimento in cache con chiave ["+keyCache+"] valore["+obj+"]: "+e.getMessage());
  914.                     }
  915.                 }
  916.                 
  917.             }finally {
  918.                 lockLatenza.release(lock, "readLatenzaInCache", idTransazione);
  919.             }

  921.         }
  922.         catch(Exception e){
  923.             this.log.error(e.getMessage(),e);
  924.             throw new Exception("Latenza, Algoritmo di Cache fallito: "+e.getMessage(),e);
  925.         }

  927.         return obj;
  928.     }
  929.     
  930.     
  931.     
  932.     
  933.     
  934.     
  935.     
  936.     
  937.     
  938.     
  939.     
  940.     
  941.     
  942.     /* ********************** STATO ************************** */
  943.     
  944.     public RisultatoStato getStato(DatiTransazione datiTransazione, IState state, String nomeAllarme) throws Exception{
  945.         
  946.         // BuildKey
  947.         StringBuilder bfKey = new StringBuilder("Stato ");
  948.         bfKey.append(nomeAllarme);
  949.         String key = bfKey.toString();
  950.         
  951.         //System.out.println("CERCO OGGETTO CON CHIAVE ["+key+"]");
  952.         
  953.         if(GestoreCacheControlloTraffico.cache!=null){
  954.             return this.getStatoInCache(key, datiTransazione, state, nomeAllarme);
  955.         }
  956.         else{
  957.             return this.datiNotifierReader.getStato(this.log, datiTransazione, state, nomeAllarme);
  958.         }
  959.     }
  960.     
  961.     private RisultatoStato getStatoInCache(String keyCache,DatiTransazione datiTransazione, IState state, 
  962.             String nomeAllarme) throws Exception{

  964.         RisultatoStato obj = null;
  965.         try{

  967.             if(keyCache == null)
  968.                 throw new Exception("KeyCache non definita");

  970.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  971.             if(cache!=null){
  972.                 org.openspcoop2.utils.cache.CacheResponse response = 
  973.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  974.                 if(response != null){
  975.                     if(response.getObject()!=null){
  976.                         this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  977.                         //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  978.                         return (RisultatoStato) response.getObject();
  979.                     }else if(response.getException()!=null){
  980.                         this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  981.                         throw (Exception) response.getException();
  982.                     }else{
  983.                         this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  984.                     }
  985.                 }
  986.             }
  987.             
  988.             String idTransazione = datiTransazione!=null ? datiTransazione.getIdTransazione() : null;
  989.             //synchronized (semaphoreStato) {
  990.             SemaphoreLock lock = lockStato.acquire("getStatoInCache", idTransazione);
  991.             try {
  992.                 
  993.                 // se e' attiva una cache provo ad utilizzarla
  994.                 if(cache!=null){
  995.                     org.openspcoop2.utils.cache.CacheResponse response = 
  996.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(keyCache);
  997.                     if(response != null){
  998.                         if(response.getObject()!=null){
  999.                             this.log.debug("Oggetto (tipo:"+response.getObject().getClass().getName()+") con chiave ["+keyCache+"] valore["+response.getObject()+"] in cache.");
  1000.                             //System.out.println("RITORNO OGGETTO IN CACHE CON CHIAVE ["+keyCache+"]: ["+response.getObject()+"]");
  1001.                             return (RisultatoStato) response.getObject();
  1002.                         }else if(response.getException()!=null){
  1003.                             this.log.debug("Eccezione (tipo:"+response.getException().getClass().getName()+") con chiave ["+keyCache+"] in cache.");
  1004.                             throw (Exception) response.getException();
  1005.                         }else{
  1006.                             this.log.error("In cache non e' presente ne un oggetto ne un'eccezione.");
  1007.                         }
  1008.                     }
  1009.                 }
  1010.     
  1011.                 // Effettuo le query nella mia gerarchia di registri.
  1012.                 this.log.debug("oggetto con chiave ["+keyCache+"] non in cache, effettuo ricerca...");
  1013.                 try{
  1014.                     obj = this.datiNotifierReader.getStato(this.log, datiTransazione, state, nomeAllarme);
  1015.                 }catch(Exception e){
  1016.                     throw e;
  1017.                 }
  1018.     
  1019.                 // Aggiungo la risposta in cache (se esiste una cache)  
  1020.                 // Se ho una eccezione aggiungo in cache solo una not found
  1021.                 if( cache!=null ){  
  1022.                     if(obj!=null){
  1023.                         this.log.debug("Aggiungo oggetto con chiave ["+keyCache+"] valore["+obj+"] in cache");
  1024.                     }else{
  1025.                         throw new Exception("Ricerca ha ritornato un valore null");
  1026.                     }
  1027.                     try{    
  1028.                         org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  1029.                         responseCache.setObject((java.io.Serializable)obj);
  1030.                         cache.put(keyCache,responseCache);
  1031.                     }catch(UtilsException e){
  1032.                         this.log.error("Errore durante l'inserimento in cache con chiave ["+keyCache+"] valore["+obj+"]: "+e.getMessage());
  1033.                     }
  1034.                 }
  1035.                 
  1036.             }finally {
  1037.                 lockStato.release(lock, "getStatoInCache", idTransazione);
  1038.             }

  1040.         }
  1041.         catch(Exception e){
  1042.             this.log.error(e.getMessage(),e);
  1043.             throw new Exception("Stato, Algoritmo di Cache fallito: "+e.getMessage(),e);
  1044.         }

  1046.         return obj;
  1047.     }
  1048. }
Created with JaCoCo 0.8.8.202204050719