GestoreCacheResponseCaching.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.response_caching;

  22. import java.text.SimpleDateFormat;
  23. import java.util.Date;

  25. import org.openspcoop2.core.commons.CoreException;
  26. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  27. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  28. import org.openspcoop2.utils.SemaphoreLock;
  29. import org.openspcoop2.utils.UtilsException;
  30. import org.openspcoop2.utils.cache.Cache;
  31. import org.openspcoop2.utils.cache.CacheAlgorithm;
  32. import org.openspcoop2.utils.cache.CacheType;
  33. import org.openspcoop2.utils.date.DateManager;
  34. import org.openspcoop2.utils.date.DateUtils;
  35. import org.openspcoop2.utils.id.UniqueIdentifierManager;
  36. import org.slf4j.Logger;

  38. /**     
  39.  * GestoreCacheResponseCaching
  40.  *
  41.  * @author Poli Andrea (poli@link.it)
  42.  * @author $Author$
  43.  * @version $Rev$, $Date$
  44.  */
  45. public class GestoreCacheResponseCaching {

  47.     /** Chiave della cache per l'autenticazione Buste  */
  48.     private static final String RESPONSE_CACHING_CACHE_NAME = "responseCaching";
  49.     /** Cache */
  50.     private static Cache cache = null;
  51.     private static final org.openspcoop2.utils.Semaphore lock_cache = new org.openspcoop2.utils.Semaphore("GestoreCacheResponseCaching");
  52.     

  54.     /* --------------- Cache --------------------*/
  55.     public static boolean isCacheAbilitata() {
  56.         return cache!=null;
  57.     }
  58.     public static void resetCache() throws Exception{
  59.         try{
  60.             if(cache!=null){
  61.                 cache.clear();
  62.             }
  63.         }catch(Exception e){
  64.             throw new Exception("Reset della cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  65.         }
  66.     }
  67.     public static String printStatsCache(String separator) throws Exception{
  68.         try{
  69.             if(cache!=null){
  70.                 try{
  71.                     return cache.printStats(separator);
  72.                 }catch(Exception e){
  73.                     throw new Exception(e.getMessage(),e);
  74.                 }
  75.             }else{
  76.                 throw new Exception("Cache non abilitata");
  77.             }
  78.         }catch(Exception e){
  79.             throw new Exception("Visualizzazione Statistiche riguardante la cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  80.         }
  81.     }
  82.     public static void abilitaCache() throws Exception{
  83.         try{
  84.             if(cache!=null)
  85.                 throw new Exception("Cache gia' abilitata");
  86.             else{
  87.                 _abilitaCache();
  88.             }
  89.         }catch(Exception e){
  90.             throw new Exception("Abilitazione cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  91.         }
  92.     }
  93.     private static synchronized void _abilitaCache() throws Exception{
  94.         try{
  95.             if(cache==null) {
  96.                 cache = new Cache(CacheType.JCS, RESPONSE_CACHING_CACHE_NAME);  // lascio JCS come default abilitato via jmx
  97.                 cache.build();
  98.             }
  99.         }catch(Exception e){
  100.             throw new Exception("Abilitazione cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  101.         }
  102.     }
  103.     public static void abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond, Logger log) throws Exception{
  104.         try{
  105.             if(cache!=null)
  106.                 throw new Exception("Cache gia' abilitata");
  107.             else{
  108.                 int dimensione = -1;
  109.                 if(dimensioneCache!=null){
  110.                     dimensione = dimensioneCache.intValue();
  111.                 }
  112.                 initCache(CacheType.JCS, dimensione, algoritmoCacheLRU, itemIdleTime, itemLifeSecond, log);  // lascio JCS come default abilitato via jmx
  113.             }
  114.         }catch(Exception e){
  115.             throw new Exception("Abilitazione cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  116.         }
  117.     }
  118.     public static void disabilitaCache() throws Exception{
  119.         try{
  120.             if(cache==null)
  121.                 throw new Exception("Cache gia' disabilitata");
  122.             else{
  123.                 _disabilitaCache();
  124.             }
  125.         }catch(Exception e){
  126.             throw new Exception("Disabilitazione cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  127.         }
  128.     }   
  129.     private static synchronized void _disabilitaCache() throws Exception{
  130.         try{
  131.             if(cache!=null) {
  132.                 cache.clear();
  133.                 cache = null;
  134.             }
  135.         }catch(Exception e){
  136.             throw new Exception("Disabilitazione cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  137.         }
  138.     }   
  139.     public static String listKeysCache(String separator) throws Exception{
  140.         try{
  141.             if(cache!=null){
  142.                 try{
  143.                     return cache.printKeys(separator);
  144.                 }catch(Exception e){
  145.                     throw new Exception(e.getMessage(),e);
  146.                 }
  147.             }else{
  148.                 throw new Exception("Cache non abilitata");
  149.             }
  150.         }catch(Exception e){
  151.             throw new Exception("Visualizzazione chiavi presenti nella cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  152.         }
  153.     }
  154.     
  155.     public static String getObjectCache(String key) throws Exception{
  156.         try{
  157.             if(cache!=null){
  158.                 try{
  159.                     Object o = cache.get(key);
  160.                     if(o!=null){
  161.                         return o.toString();
  162.                     }else{
  163.                         return "oggetto con chiave ["+key+"] non presente";
  164.                     }
  165.                 }catch(Exception e){
  166.                     throw new Exception(e.getMessage(),e);
  167.                 }
  168.             }else{
  169.                 throw new Exception("Cache non abilitata");
  170.             }
  171.         }catch(Exception e){
  172.             throw new Exception("Visualizzazione oggetto presente nella cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  173.         }
  174.     }
  175.     
  176.     public static void removeObjectCache(String key) throws Exception{
  177.         try{
  178.             if(cache!=null){
  179.                 try{
  180.                     cache.remove(key);
  181.                 }catch(Exception e){
  182.                     throw new Exception(e.getMessage(),e);
  183.                 }
  184.             }else{
  185.                 throw new Exception("Cache non abilitata");
  186.             }
  187.         }catch(Exception e){
  188.             throw new Exception("Rimozione oggetto presente nella cache per i dati contenenti le risposte salvate non riuscita: "+e.getMessage(),e);
  189.         }
  190.     }
  191.     

  193.     /*----------------- INIZIALIZZAZIONE --------------------*/

  195.     public static void initialize(Logger log) throws Exception{
  196.         GestoreCacheResponseCaching.initialize(null, false, -1,null,-1l,-1l, log);
  197.     }
  198.     public static void initialize(CacheType cacheType, int dimensioneCache,String algoritmoCache,
  199.             long idleTime, long itemLifeSecond, Logger log) throws Exception{
  200.         GestoreCacheResponseCaching.initialize(cacheType, true, dimensioneCache,algoritmoCache,idleTime,itemLifeSecond, log);
  201.     }

  203.     private static void initialize(CacheType cacheType, boolean cacheAbilitata,int dimensioneCache,String algoritmoCache,
  204.             long idleTime, long itemLifeSecond, Logger log) throws Exception{

  206.         // Inizializzazione Cache
  207.         if(cacheAbilitata){
  208.             GestoreCacheResponseCaching.initCache(cacheType, dimensioneCache, algoritmoCache, idleTime, itemLifeSecond, log);
  209.         }

  211.     }
  212.     private static void initCache(CacheType cacheType, Integer dimensioneCache,String algoritmoCache,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws Exception{
  213.         initCache(cacheType, dimensioneCache, CostantiConfigurazione.CACHE_LRU.toString().equalsIgnoreCase(algoritmoCache), itemIdleTime, itemLifeSecond, alog);
  214.     }
  215.     
  216.     private static void initCache(CacheType cacheType, Integer dimensioneCache,boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond,Logger alog) throws Exception{
  217.         
  218.         cache = new Cache(cacheType, RESPONSE_CACHING_CACHE_NAME);
  219.     
  220.         // dimensione
  221.         if(dimensioneCache!=null && dimensioneCache>0){
  222.             try{
  223.                 String msg = "Dimensione della cache (ResponseCaching) impostata al valore: "+dimensioneCache;
  224.                 alog.info(msg);
  225.                 cache.setCacheSize(dimensioneCache);
  226.             }catch(Exception error){
  227.                 String msg = "Parametro errato per la dimensione della cache (ResponseCaching): "+error.getMessage();
  228.                 alog.error(msg);
  229.                 throw new Exception(msg,error);
  230.             }
  231.         }
  232.         
  233.         // algoritno
  234.         String msg = "Algoritmo di cache (ResponseCaching) impostato al valore: LRU";
  235.         if(!algoritmoCacheLRU){
  236.             msg = "Algoritmo di cache (ResponseCaching) impostato al valore: MRU";
  237.         }
  238.         alog.info(msg);
  239.         if(!algoritmoCacheLRU)
  240.             cache.setCacheAlgoritm(CacheAlgorithm.MRU);
  241.         else
  242.             cache.setCacheAlgoritm(CacheAlgorithm.LRU);
  243.         
  244.         
  245.         // idle time
  246.         if(itemIdleTime!=null && itemIdleTime>0){
  247.             try{
  248.                 msg = "Attributo 'IdleTime' (ResponseCaching) impostato al valore: "+itemIdleTime;
  249.                 alog.info(msg);
  250.                 cache.setItemIdleTime(itemIdleTime);
  251.             }catch(Exception error){
  252.                 msg = "Parametro errato per l'attributo 'IdleTime' (ResponseCaching): "+error.getMessage();
  253.                 alog.error(msg);
  254.                 throw new Exception(msg,error);
  255.             }
  256.         }
  257.         
  258.         // LifeSecond
  259.         long longItemLife = -1; 
  260.         if(itemLifeSecond!=null && itemLifeSecond>0){
  261.             longItemLife = itemLifeSecond.longValue();
  262.         }
  263.         try{
  264.             msg = "Attributo 'MaxLifeSecond' (ResponseCaching) impostato al valore: "+longItemLife;
  265.             alog.info(msg);
  266.             cache.setItemLifeTime(longItemLife);
  267.         }catch(Exception error){
  268.             msg = "Parametro errato per l'attributo 'MaxLifeSecond' (ResponseCaching): "+error.getMessage();
  269.             alog.error(msg);
  270.             throw new Exception(msg,error);
  271.         }
  272.         
  273.         cache.build();
  274.     }
  275.     
  276.     
  277.     @SuppressWarnings("deprecation")
  278.     @Deprecated
  279.     public static void disableSyncronizedGet() throws UtilsException {
  280.         if(cache==null) {
  281.             throw new UtilsException("Cache disabled");
  282.         }
  283.         cache.disableSyncronizedGet();
  284.     }
  285.     @SuppressWarnings("deprecation")
  286.     @Deprecated
  287.     public static boolean isDisableSyncronizedGet() throws UtilsException {
  288.         if(cache==null) {
  289.             throw new UtilsException("Cache disabled");
  290.         }
  291.         return cache.isDisableSyncronizedGet();
  292.     }
  293.     
  294.     
  295.     
  296.     private static GestoreCacheResponseCaching staticInstance = null;
  297.     public static synchronized void initialize() {
  298.         if(staticInstance==null){
  299.             staticInstance = new GestoreCacheResponseCaching();
  300.         }
  301.     }
  302.     public static GestoreCacheResponseCaching getInstance() throws CoreException{
  303.         if(staticInstance==null){
  304.             // spotbugs warning 'SING_SINGLETON_GETTER_NOT_SYNCHRONIZED': l'istanza viene creata allo startup
  305.             synchronized (GestoreCacheResponseCaching.class) {
  306.                 throw new CoreException("GestoreCacheResponseCaching non inizializzato");
  307.             }
  308.         }
  309.         return staticInstance;
  310.     }
  311.     
  312.     private Logger log;
  313.     
  314.     private GestoreCacheResponseCaching() {
  315.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  316.     }
  317.     

  319.     
  320.     
  321.     
  322.     
  323.     
  324.     
  325.     
  326.     /* ********************** ENGINE ************************** */
  327.     
  328.     public String save(String digest, ResponseCached response) throws Exception{
  329.         
  330.         String uuid = null;
  331.         try{

  333.             if(cache==null) {
  334.                 throw new Exception("Cache per il salvataggio delle risposte non abilitata");
  335.             }
  336.             
  337.             if(digest == null)
  338.                 throw new Exception("Digest non definito");
  339.             if(response == null)
  340.                 throw new Exception("Risposta non definita");
  341.             
  342.             String digestKey = formatKeyDigest(digest);
  343.             
  344.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  345.             Object o = cache.get(digestKey);
  346.             if(o!=null) {
  347.                 org.openspcoop2.utils.cache.CacheResponse responseCache = 
  348.                         (org.openspcoop2.utils.cache.CacheResponse)  o;
  349.                 return ((ResponseCached)responseCache.getObject()).getUuid(); // already saved concurrent thread
  350.             }
  351.             
  352.             //synchronized (cache) {
  353.             SemaphoreLock lock = lock_cache.acquire("save");
  354.             try {
  355.                 
  356.                 o = cache.get(digestKey);
  357.                 if(o!=null) {
  358.                     org.openspcoop2.utils.cache.CacheResponse responseCache = 
  359.                             (org.openspcoop2.utils.cache.CacheResponse)  o;
  360.                     return ((ResponseCached)responseCache.getObject()).getUuid(); // already saved concurrent thread
  361.                 }
  362.                 
  363.                 uuid = UniqueIdentifierManager.newUniqueIdentifier().getAsString();
  364.                 String uuidKey = formatKeyUUID(uuid);
  365.                 
  366.                 try{    
  367.                     cache.put(uuidKey,digestKey);
  368.                 }catch(UtilsException e){
  369.                     this.log.error("Errore durante l'inserimento in cache con chiave ["+uuidKey+"] valore["+digestKey+"]: "+e.getMessage());
  370.                 }
  371.                 
  372.                 try{    
  373.                     org.openspcoop2.utils.cache.CacheResponse responseCache = new org.openspcoop2.utils.cache.CacheResponse();
  374.                     response.setUuid(uuid);
  375.                     response.setDigest(digest);
  376.                     responseCache.setObject((java.io.Serializable)response);
  377.                     cache.put(digestKey,responseCache);
  378.                 }catch(UtilsException e){
  379.                     this.log.error("Errore durante l'inserimento in cache con chiave ["+digestKey+"] della risposta: "+e.getMessage());
  380.                     try {
  381.                         cache.remove(uuidKey); // precedentemente aggiunto
  382.                     }catch(Throwable tIgnore) {}
  383.                 }
  384.                 
  385.             }finally {
  386.                 lock_cache.release(lock, "save");
  387.             }

  389.         }
  390.         catch(Exception e){
  391.             this.log.error(e.getMessage(),e);
  392.             throw new Exception("Salvataggio in Cache fallito: "+e.getMessage(),e);
  393.         }

  395.         return uuid;
  396.         
  397.     }
  398.     
  399.     
  400.     
  401.     public ResponseCached readByUUID(String uuid) throws Exception{
  402.         
  403.         try{

  405.             if(cache==null) {
  406.                 throw new Exception("Cache per il salvataggio delle risposte non abilitata");
  407.             }
  408.             
  409.             if(uuid == null)
  410.                 throw new Exception("UUID non definito");

  412.             String uuidKey = formatKeyUUID(uuid);
  413.             
  414.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  415.             
  416.             Object oDigest = cache.get(uuidKey);
  417.             if(oDigest==null) {
  418.                 return null; // messaggio non precedentemente salvato
  419.             }
  420.             
  421.             String digest = (String) oDigest;
  422.             String digestKey = formatKeyDigest(digest);
  423.             
  424.             org.openspcoop2.utils.cache.CacheResponse response = 
  425.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(digestKey);
  426.             if(response == null || response.getObject()==null){
  427.                 // la rimozione la faccio in modalita' sincronizzata
  428.             }
  429.             else {
  430.                 ResponseCached responseCached = (ResponseCached) response.getObject();
  431.                 Date now = DateManager.getDate();
  432.                 if(now.after(responseCached.getScadenza())) {
  433.                     // la rimozione la faccio in modalita' sincronizzata
  434.                 }
  435.                 else {
  436.                     return responseCached;
  437.                 }
  438.             }
  439.             
  440.             //synchronized (cache) {
  441.             SemaphoreLock lock = lock_cache.acquire("readByUUID");
  442.             try {
  443.                 
  444.                 oDigest = cache.get(uuidKey);
  445.                 if(oDigest==null) {
  446.                     return null; // messaggio non precedentemente salvato
  447.                 }
  448.                 digest = (String) oDigest;
  449.                 digestKey = formatKeyDigest(digest);
  450.             
  451.                 response = 
  452.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(digestKey);
  453.                 if(response == null || response.getObject()==null){
  454.                     this.log.error("In cache non è presente il mapping uuid ("+uuidKey+") - digest ("+digestKey+") ma poi non esiste l'oggetto??");
  455.                     cache.remove(uuidKey);
  456.                     return null;
  457.                 }
  458.                 
  459.                 ResponseCached responseCached = (ResponseCached) response.getObject();
  460.                 Date now = DateManager.getDate();
  461.                 if(now.after(responseCached.getScadenza())) {
  462.                     SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  463.                     String scadenza = dateformat.format(responseCached.getScadenza());
  464.                     String nowS = dateformat.format(now);
  465.                     this.log.debug("In cache è presente un messaggio [uuid ("+uuidKey+") - digest ("+digestKey+")] scaduto (scadenza:"+scadenza+") (now:"+nowS+")");
  466.                     cache.remove(uuidKey);
  467.                     cache.remove(digestKey);
  468.                     return null;
  469.                 }
  470.                 
  471.                 return responseCached;
  472.                 
  473.             }finally {
  474.                 lock_cache.release(lock, "readByUUID");
  475.             }

  477.         }
  478.         catch(Exception e){
  479.             this.log.error(e.getMessage(),e);
  480.             throw new Exception("Lettura messaggio in Cache fallito: "+e.getMessage(),e);
  481.         }
  482.         
  483.     }
  484.     
  485.     public void removeByUUID(String uuid) throws Exception{
  486.         
  487.         try{

  489.             if(cache==null) {
  490.                 throw new Exception("Cache per il salvataggio delle risposte non abilitata");
  491.             }
  492.             
  493.             if(uuid == null)
  494.                 throw new Exception("UUID non definito");

  496.             String uuidKey = formatKeyUUID(uuid);
  497.             
  498.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  499.             
  500.             Object oDigest = cache.get(uuidKey);
  501.             if(oDigest==null) {
  502.                 return; // messaggio non precedentemente salvato
  503.             }
  504.                         
  505.             //synchronized (cache) {
  506.             SemaphoreLock lock = lock_cache.acquire("removeByUUID");
  507.             try {
  508.                 
  509.                 oDigest = cache.get(uuidKey);
  510.                 if(oDigest==null) {
  511.                     return; // messaggio non precedentemente salvato
  512.                 }
  513.                 String digest = (String) oDigest;
  514.                 String digestKey = formatKeyDigest(digest);
  515.             
  516.                 org.openspcoop2.utils.cache.CacheResponse response = 
  517.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(digestKey);
  518.                 if(response == null || response.getObject()==null){
  519.                     this.log.error("In cache non è presente il mapping uuid ("+uuidKey+") - digest ("+digestKey+") ma poi non esiste l'oggetto??");
  520.                     cache.remove(uuidKey);
  521.                     return;
  522.                 }
  523.                 
  524.                 cache.remove(uuidKey);
  525.                 cache.remove(digestKey);
  526.                 
  527.             }finally{
  528.                 lock_cache.release(lock, "removeByUUID");
  529.             }

  531.         }
  532.         catch(Exception e){
  533.             this.log.error(e.getMessage(),e);
  534.             throw new Exception("Rimozione messaggio in Cache fallito: "+e.getMessage(),e);
  535.         }
  536.         
  537.     }
  538.     
  539.     public ResponseCached readByDigest(String digest) throws Exception{
  540.         
  541.         try{

  543.             if(cache==null) {
  544.                 throw new Exception("Cache per il salvataggio delle risposte non abilitata");
  545.             }
  546.             
  547.             if(digest == null)
  548.                 throw new Exception("Digest non definito");

  550.             String digestKey = formatKeyDigest(digest);
  551.                 
  552.             
  553.             // Fix: devo prima verificare se ho la chiave in cache prima di mettermi in sincronizzazione.
  554.             
  555.             org.openspcoop2.utils.cache.CacheResponse response = 
  556.                     (org.openspcoop2.utils.cache.CacheResponse) cache.get(digestKey);
  557.             if(response == null || response.getObject()==null){
  558.                 return null;
  559.             }
  560.             
  561.             ResponseCached responseCached = (ResponseCached) response.getObject();
  562.             Date now = DateManager.getDate();
  563.             if(now.after(responseCached.getScadenza())) {
  564.                 // effettuo il controllo in modalita' sincronizzazione per fare le rimozioni
  565.             }
  566.             else {
  567.                 return responseCached;
  568.             }
  569.                         
  570.             //synchronized (cache) {
  571.             SemaphoreLock lock = lock_cache.acquire("readByDigest");
  572.             try {
  573.                 
  574.                 response = 
  575.                         (org.openspcoop2.utils.cache.CacheResponse) cache.get(digestKey);
  576.                 if(response == null || response.getObject()==null){
  577.                     return null;
  578.                 }
  579.                 
  580.                 responseCached = (ResponseCached) response.getObject();
  581.                 now = DateManager.getDate();
  582.                 if(now.after(responseCached.getScadenza())) {
  583.                     String uuidKey = formatKeyUUID(responseCached.getUuid());
  584.                     SimpleDateFormat dateformat = DateUtils.getSimpleDateFormatMs();
  585.                     String scadenza = dateformat.format(responseCached.getScadenza());
  586.                     String nowS = dateformat.format(now);
  587.                     this.log.debug("In cache è presente un messaggio [uuid ("+uuidKey+") - digest ("+digestKey+")] scaduto (scadenza:"+scadenza+") (now:"+nowS+")");
  588.                     cache.remove(uuidKey);
  589.                     cache.remove(digestKey);
  590.                     return null;
  591.                 }

  593.                 return responseCached;
  594.                 
  595.             }finally {
  596.                 lock_cache.release(lock, "readByDigest");
  597.             }

  599.         }
  600.         catch(Exception e){
  601.             this.log.error(e.getMessage(),e);
  602.             throw new Exception("Lettura messaggio in Cache fallito: "+e.getMessage(),e);
  603.         }
  604.         
  605.     }
  606.     
  607.     
  608.     public static String formatKeyUUID(String uuid) {
  609.         String prefix = "uuid:";
  610.         if(uuid.startsWith(prefix)==false) {
  611.             return prefix+uuid;
  612.         }
  613.         else {
  614.             return uuid;
  615.         }
  616.     }
  617.     
  618.     public static String formatKeyDigest(String digest) {
  619.         String prefix = "digest:";
  620.         if(digest.startsWith(prefix)==false) {
  621.             return prefix+digest;
  622.         }
  623.         else {
  624.             return digest;
  625.         }
  626.     }
  627. }
Created with JaCoCo 0.8.8.202204050719